Is this the simplest way to create const / non const class?

I wanted to do a class that works similarly to an array.

However most of my pointers were const, and I had problems even if I use MyArray<const int>.

This is why i "separated" const and non const class.

However I feel all code inside my_array_impl_ namespace is bit redundant.

Is there easier way to achieve the same with less code? Thanks

	namespace my_array_impl_{

		template<typename T, bool b>
		struct TFactory;

		template<typename T>
		struct TFactory<T, false>{
			using type	= const T;
			using type_void	= const void *;
		};

		template<typename T>
		struct TFactory<T, true>{
			using type	= T;
			using type_void	= void *;
		};

	}

	template<typename T_, bool M_ = false>
	class MyArray{
		using MyTFactory	= my_array_impl_::TFactory<T_, M_>;

		using T			= typename MyTFactory::type;
		using Void		= typename MyTFactory::type_void;

		T	*ptr_;
		size_t	size_;

	public:
		constexpr MyArray(Void ptr, size_t size) :
				ptr_	(reinterpret_cast<T *>(ptr)	),
				size_	(size / sizeof(T)			){}

		explicit
		constexpr MyArray(std::string_view s) :
				MyArray(s.data(), s.size()){}

	public:
		constexpr size_t size() const{
			return size_;
		}

		constexpr const auto&operator[](size_t i) const{
			return ptr_[i];
		}

		constexpr auto&operator[](size_t i){
			return ptr_[i];
		}
	};

	template<typename T>
	using MyArrayMutable = MyArray<T, true>;

All code can be simplified with std::conditional:

		template<typename T>
		using TFactory		= std::conditional_t<Mutable, T, const T>;

		using T			= TFactory<T_		>;
		using Void		= TFactory<void	*	>;