Класс для хранения массива данных

#include <algorithm>
#include <cassert>
#include <memory>
#include <stdexcept>
 
template <typename T>
class my_array {
 
   std::unique_ptr<T[]> array_;
   std::size_t size_ = 0;
 
   void assign(const T* const array) noexcept
   {
      std::copy(array, array + size_, array_.get());
   }
 
public:
   my_array() = default;
 
   my_array(const T* const array, std::size_t size) : array_(new T[size]), size_(size)
   {
      assign(array);
   }
 
   my_array(const my_array &rhs) : array_(new T[rhs.size_]), size_(rhs.size_)
   {
      assign(rhs.array_.get());
   }
 
   my_array(my_array &&rhs) noexcept :
      array_(std::move(rhs.array_)), size_(rhs.size_)
   {
      rhs.size_ = 0;
   }
 
   my_array & operator =(const my_array &rhs)
   {
      my_array tmp(rhs);
      swap(tmp);
      return *this;
   }
 
   my_array & operator =(my_array &&rhs) noexcept
   {
      array_ = std::move(rhs.array_);
      size_ = rhs.size_;
      rhs.size_ = 0;
      return *this;
   }
 
   T& operator [] (std::size_t idx)
   {
      if (idx >= size_) throw std::out_of_range("my_array");
      return array_[idx];
   }
 
   const T& operator [] (std::size_t idx) const
   {
      return const_cast<my_array&>(*this)[idx];
   }
 
   void swap(my_array &rhs) noexcept
   {
      std::swap(array_, rhs.array_);
      std::swap(size_, rhs.size_);
   }
 
   std::size_t size() const noexcept { return size_; }
 
};
 
int main()
{
   int array[] = {1,2,3};
   my_array<int> a{array, sizeof(array) / sizeof(*array)};
   my_array<int> a_copied(a);
   my_array<int> a_moved(std::move(a));
   assert(a.size() == 0);
   my_array<int> a_cassigned;
   a_cassigned = a_copied;
   assert(a_cassigned.size() == a_copied.size());
   my_array<int> a_massigned;
   a_massigned = std::move(a_copied);
   assert(a_copied.size() == 0 && a_moved.size() == 3);
   assert(a_massigned[2] == 3);
}