Утечка памяти. class my_array

#include <assert.h>
#include <algorithm> // std::copy
#include <cstddef> // size_t
#include <iostream>
 
template<typename T>
class Array
{
public:
  // (default) constructor
  Array(const size_t size = 0)
    : m_size(size)
    , m_array(m_size ? new T[m_size]() : nullptr)
  {
 
  }
    //my copy constructor
    Array(const Array & Arr) : m_size(0), m_array(nullptr)
    {
        if (Arr.m_size == 0)
        {
            assert(Arr.m_array == nullptr);
            return;
        }
        m_size = Arr.m_size;
        m_array = new T[m_size];
        for (size_t i = 0; i != m_size; i++) m_array[i] = Arr.m_array[i];
        //  std::copy(Arr.m_array, Arr.m_array + m_size, m_array);
    }
 
  //my move constructor
  Array(Array && Arr) : m_size(0), m_array(nullptr)
  {
        if (Arr.m_size == 0)
        {
            assert(Arr.m_array == nullptr);
            return;
        }
        m_size = Arr.m_size;
        m_array = Arr.m_array;
        Arr.m_size = 0;
        Arr.m_array = nullptr;
  }
   
  //my swap
  void swap(Array & Arr)
  {
      std::swap(m_size, Arr.m_size);
      std::swap(m_array, Arr.m_array);
  }
 
  //my operator =
  Array & operator = (Array const& Arr)
  {
      if (this != &Arr) Array(Arr).swap(*this);
      return *this;
  }
  
 
/*  Array & operator = (Array const& Arr)
  {
      if (this != &Arr)
      {
          delete [] m_array;
          m_size = Arr.m_size;
          m_array = new T[m_size];
          std::copy(Arr.m_array, Arr.m_array + m_size, m_array);
      }
  }
 
  Array & operator = (Array const& Arr)
  {
        if (this != &Arr)
        {
            T * new_array = new T[Arr.m_size];
            std::copy(Arr.m_array, Arr.m_array + Arr.m_size, new_array);
            delete [] m_array;
            m_array = new_array;
            m_size = Arr.m_size;
        }
        return *this;
  }*/
    
  Array & operator = (Array&& Arr)
  {
      destroy();
      m_size = Arr.m_size;
      m_array = Arr.m_array;
      Arr.m_array = nullptr;
      return *this;
  }
  
  const size_t size() const
  {
    return m_size;
  }
 
  T& operator [](const size_t index)
  {
    assert(index < m_size);
 
    return m_array[index];
  }                                       
  
      ~Array() {destroy();}
  void out()
  {
    for (size_t i = 0; i != m_size; i++)
        std::cout << m_array[i] << " ";
    std::cout << std::endl;
  }
 
private:
    void destroy() 
    { 
        if (m_size)
        {
            delete[] m_array;
      m_size = 0;
            return;
        }
    }
  size_t m_size;
  T* m_array;
};
 
int main()
{
    Array<int> arr1(10);
    //Array<int> arr2(arr1);
    //Array<int> arr3 = arr2;
    //arr1.out(); arr2.out(); arr3.out();
}

, m_array(m_size ? new T[m_size]() : nullptr)

  ~Array() {destroy();}
 
 void destroy() 
    { 
        if (m_size)
        {
            delete[] m_array;
      m_size = 0;
            return;
        }
    }

  Array(const size_t size = 0)
    : m_size(size)
    , m_array(m_size ? new T[m_size] : nullptr)
  {
  }

class MyClass
{
public:
    MyClass()
    {
        m = new int[5];
    }
    MyClass(int a)
    {
        m = new int[5];
    }
    ~MyClass()
    {
        delete[] m;
    }
private:
    int *m;
};
 
int main()
{
    MyClass m;
}