Двумерный массив и перегрузка оператора =

template<typename TT>
class Matrix
{   
public:
//======================================================================================================
    Matrix<TT>(int Row, int Col)
    {
        RowCount = Row; ColCount = Col;
        Array = new TT *[RowCount];
        for (int index = 0; index < RowCount; index++)
            Array[index] = new TT [ColCount];
 
        // Это только для тестирования методов
        int index1 = 0, index2 = 0;
        for(index1 = 0; index1 < RowCount; index1++)
            //for(index2 = 0; index2 < ColCount; index2++)
        {
            Array[index1][0] = 1;
            Array[index1][1] = 2; 
            Array[index1][2] = 3;
        } 
    }
//======================================================================================================
    ~Matrix<TT>()
    {
        for(int index = 0; index < RowCount; index++)
            delete[] Array[index];
        delete[] Array;
        cout << "Destructor....";
        _getch();
    }
//======================================================================================================
    TT operator ()(int IND1, int IND2)
    {
        return Array[IND1][IND2];
    }
//======================================================================================================
    Matrix & operator = (const Matrix & m)
    {
 
    }
//======================================================================================================
    void SetIdenty()
    {
        if (RowCount == ColCount)
        {
            int IND1, IND2;
            for (IND1 = 0; IND1 < RowCount; IND1++)
                for (IND2 = 0; IND2 < RowCount; IND2++)
                {
                    Array[IND1][IND2] = 0;
                    Array[IND2][IND2] = 1;
                }
        }
    }
//======================================================================================================
    void Transpose()
    {
        int newRowCount = ColCount, newColCount = RowCount;
        // Создаем вспомогательный массив
        TT **Arr = new TT *[newColCount];
        for (int i = 0; i < newColCount; i++)
        {
            Arr[i] = new TT[newRowCount];
            // Присваиваем строки массива Array столбцам массива Arr
            for (int j = 0; j < newColCount; j++)
                Arr[i][j] = Array[j][i];
        }
        // Освобождаем память Array
        for(int index = 0; index < RowCount; index++)
            delete[] Array[index];
        delete[] Array;
        // Присваиваем Arr
        Array = Arr;
        ColCount = newColCount;
        RowCount = newRowCount;
    }
//======================================================================================================
private:
    int RowCount, ColCount;
    TT **Array;
};

const Matrix<TT> & operator = (const Matrix<TT> & m)
    {
 if(&m == this) return *this;
for(int index = 0; index < RowCount; index++)
            delete[] Array[index];
        delete[] Array;
RowCount = m.RowCount;
ColCount = m.ColCount;
Array = new TT *[RowCount];
        for (int index = 0; index < RowCount; index++)
            Array[index] = new TT [ColCount];
for (int i = 0; i < RowCount; j++)
for (int j = 0; j < ColCount; j++)
Array[i][j] = m.Array[i][j];
return *this;
    }

Matrix(const Matrix & r);