Организовать класс квадратная матрица размерности 3 на 3, содержащий методы

#include <ctime>
#include <cstdlib>
#include <iostream>
 
class Matrix
{
public:
    int m_nRows;
    int m_nCols;
 
private:
    int** m_ppMatrix;
    int m_nCount;
 
public:
    Matrix() { };
    Matrix(int nRows, int nCols) 
    { 
        m_nRows = nRows; m_nCols = nCols;
        m_ppMatrix = nullptr; m_nCount = 0;
    };
 
    Matrix(Matrix& m)
    {
        if (m.m_nRows == m.m_nCols)
        {
            for (int iRow = 0; iRow < m.m_nRows; iRow++)
                 this->AddRow(m.GetRow(iRow));
        }
    }
 
    ~Matrix()
    {
        for (int iRow = 0; iRow < m_nRows; iRow++)
            delete[] m_ppMatrix[iRow];
 
        delete[] m_ppMatrix;
    }
 
public:
    Matrix& operator=(Matrix& m)
     { return Matrix(m); }
 
    int*& operator[](int nRow)
     { return (int*&)this->GetRow(nRow); }
 
private:
    friend int _Min(int n1, int n2);
 
public:
    void AddRow(int*& pRow)
    {
        if (m_nCount > m_nRows || 
            sizeof(pRow) / sizeof(pRow[0]) > m_nCols) return;
 
        int** pTemp = new int*[m_nCount + 1];
        if (m_ppMatrix != NULL)
            memcpy((void*)pTemp, (const void*)m_ppMatrix, 4 * m_nCount);
 
        pTemp[m_nCount] = new int[m_nCols];
        memcpy((void*)pTemp[m_nCount], (const void*)pRow, sizeof(int) * m_nCols);
 
        if (pTemp != nullptr)
        {
            m_ppMatrix = pTemp; m_nCount++;
        }
    }
 
    int*& GetRow(int nRow)
    {
        return m_ppMatrix[nRow];
    }
 
    Matrix& Transponent()
    {
        int* pRow = new int[this->m_nCols];
        memset((void*)&pRow[0], 0x00, sizeof(int) * this->m_nCols);
 
        Matrix* pMatrix = new Matrix(this->m_nRows, this->m_nCols);
        for (int iRow = 0; iRow < pMatrix->m_nRows; iRow++)
            pMatrix->AddRow(pRow);
 
        if (pMatrix->m_nRows == pMatrix->m_nCols)
        {
            for (int iRow = 0; iRow < this->m_nRows; iRow++)
                for (int iCol = 0; iCol < this->m_nCols; iCol++)
                    (*pMatrix)[iCol][iRow] = m_ppMatrix[iRow][iCol];
        }
 
        return (*pMatrix);
    }
 
    float GetDeterminant(Matrix& m, int nRows)
    {
        if (nRows > 2)
        {
            float nRet = 0;
            bool b1 = false;
 
            int* pRow = new int[nRows];
            memset((void*)&pRow[0], 0x00, sizeof(int) * nRows);
 
            Matrix* pMatrixA = new Matrix(nRows, nRows);
            for (int iRow = 0; iRow < pMatrixA->m_nRows; iRow++)
                 pMatrixA->AddRow(pRow);
 
            for (int iRow = 0; iRow < nRows; iRow++)
                for (int iCol = 0; iCol < nRows; iCol++)
                    (*pMatrixA)[iRow][iCol] = m[iRow][iCol];
 
            int* pRow2 = new int[nRows - 1];
            memset((void*)&pRow2[0], 0x00, sizeof(int) * (nRows - 1));
 
            Matrix* pMatrixB = new Matrix(nRows, nRows - 1);
            for (int iRow = 0; iRow < pMatrixA->m_nRows; iRow++)
                pMatrixB->AddRow(pRow2);
 
            for (int i1 = 0; i1 < nRows; i1++)
            {
                for (int i2 = 0; i2 < nRows; i2++)
                {
                    for (int i3 = 0; i3 < nRows; i3++)
                    {
                        if (i3 != i1 && i2 != 0)
                            if (b1 == false) 
                                (*pMatrixB)[i2 - 1][i3] = (*pMatrixA)[i2][i3];
                            else (*pMatrixB)[i2 - 1][i3 - 1] = (*pMatrixA)[i2][i3];
                        else b1 = true;
                    }
 
                    b1 = false;
                }
 
                if (((i1 + 2) % 2) == 0) 
                    nRet += (*pMatrixA)[0][i1] * GetDeterminant((*pMatrixB), nRows - 1);
                else nRet -= (*pMatrixA)[0][i1] * GetDeterminant((*pMatrixB), nRows - 1);
            }
 
            return nRet;
        }
 
        else if (nRows == 2) return float((m[0][0] * m[1][1]) - (m[1][0] * m[0][1]));
        else if (nRows == 1) return float(m[0][0]);
 
        return 0;
    }
 
    int GetRank()
    {
        int nRank = 0;
        for (int nRows = 0; nRows <= _Min(this->m_nRows, this->m_nCols); nRows++)
        {
            int* pRow = new int[this->m_nCols];
            memset((void*)&pRow[0], 0x00, sizeof(int) * this->m_nCols);
 
            Matrix* pMatrix = new Matrix(this->m_nRows, this->m_nCols);
            for (int iRow = 0; iRow < pMatrix->m_nRows; iRow++)
                pMatrix->AddRow(pRow);
 
            for (int iRow1 = 0; iRow1 < (this->m_nRows - (nRows - 1)); iRow1++)
                for (int iCol1 = 0; iCol1 < (this->m_nCols - (nRows - 1)); iCol1++)
                {
                    for (int iRow2 = 0; iRow2 < nRows; iRow2++)
                        for (int iCol2 = 0; iCol2 < nRows; iCol2++)
                            (*pMatrix)[iRow2][iCol2] = m_ppMatrix[iRow1 + iRow2][iCol1 + iCol2];
 
                    nRank = (this->GetDeterminant((*pMatrix), nRows) != 0) ? nRows : nRank;
                }
        }
 
        return nRank;
    }
 
    void Show()
    {
        for (int iRow = 0; iRow < m_nRows; iRow++)
        {
            for (int iCol = 0; iCol < m_nCols; iCol++)
                std::cout << m_ppMatrix[iRow][iCol] << " ";
 
            std::cout << "\n";
        }
 
        std::cout << "\n";
    }
};
 
int _Min(int n1, int n2)
{
    return n1 < n2 ? n1 : n2;
}
 
 
const int N = 10, M = 10;
 
int main()
{
    std::srand((unsigned)std::time(nullptr));
 
    int** matrix = new int*[N];
    memset((void*)&matrix[0], 0x00, 4 * N);
 
    for (int i = 0; i < N; i++)
    {
        matrix[i] = new int[M];
        memset((void*)&matrix[i][0], 0x00, sizeof(int) * M);
        for (int j = 0; j < M; j++)
            matrix[i][j] = std::rand() % (N - 1) + 1;
    }
 
    Matrix m(N,M);
 
    for (int i = 0; i < N; i++)
        m.AddRow(matrix[i]);
 
    m.Show();
 
    Matrix& result = m.Transponent();
 
    result.Show();
 
    std::cout << "rank = " << result.GetRank() << "\n";
 
    std::cin.get();
    std::cin.get();
}