Описать класс для работы с целочисленной матрицей произвольного размера

#include <iostream>
#include <cstdlib>
#include <ctime>
 
using namespace std;
 
typedef unsigned int UINT;
 
class Matrix
{
public:
    Matrix ( UINT row, UINT col );
    Matrix ( const Matrix &obj );
    ~Matrix ();
 
    void fill ( UINT N );
    void get_size ( UINT &row, UINT &col );
    void print();
    void multiplication ( const Matrix &obj );
 
private:
    int **p;
    /*const */UINT nRow, nColumn;
 
    Matrix& operator = ( const Matrix &obj );
};
 
Matrix::Matrix ( UINT row, UINT col )
: nRow( row > 0 && col > 0 ? row : 0 )
, nColumn( row > 0 && col > 0 ? col : 0 )
{
    if ( nRow == 0 )
    {
        p = NULL;
        return;
    }
 
    p = new int* [nRow];
    *p = new int [nRow*nColumn+1];
    for (UINT i = 1; i < nRow; i++)
        p[i] = p[i-1] + nColumn;
}
 
Matrix::Matrix ( const Matrix &obj )
: nRow( obj.nRow )
, nColumn( obj.nColumn )
{
    if ( nRow == 0 )
    {
        p = NULL;
        return;
    }
 
    p = new int* [nRow];
    *p = new int [nRow*nColumn+1];
    for (UINT i = 1; i < nRow; i++)
    {
        if ( i == 0 )
            p[i] = p[i-1] + nColumn;
 
        for (UINT j = 0; j < nColumn; j++)
            p[i][j] = obj.p[i][j];
    }
}
 
Matrix::~Matrix()
{
    if ( p != NULL )
    {
        delete[] *p;
        delete[] p;
    }
}
 
void Matrix::fill ( UINT N )
{
    srand( time( NULL ) );
 
    for (UINT i = 0; i < nRow; i++)
        for (UINT j = 0; j < nColumn; j++)
            this->p[i][j] = -N + rand() % (2*N);
}
 
void Matrix::get_size ( UINT &row, UINT &col )
{
    row = nRow;
    col = nColumn;
}
 
void Matrix::print()
{
    for (UINT i = 0; i < nRow; i++)
    {
        for (UINT j = 0; j < nColumn; j++)
        {
            cout.width( 5 );
            cout << this->p[i][j];
        }
        cout << endl;
    }
}
 
void Matrix::multiplication ( const Matrix &obj )
{
    if ( this->nColumn != obj.nRow )
    {
        cout << "Different sizes" << endl;
        return;
    }
 
    int **c = new int* [this->nRow];
    *c = new int [this->nRow*obj.nColumn+1];
    for (UINT i = 1; i < this->nRow; i++)
        c[i] = c[i-1] + obj.nColumn;
 
    for (UINT i = 0; i < this->nRow; i++)
        for (UINT j = 0; j < this->nColumn; j++)
        {
            c[i][j] = 0;
            for (UINT k = 0; k < this->nColumn; k++)
                c[i][j] += this->p[i][k] * obj.p[k][j];
        }
 
    delete[] *p;
    delete[] p;
 
    this->p = c;
    *(this->p) = *c;
 
    this->nColumn = obj.nColumn;
}
 
int main()
{
    Matrix A(2, 3), B(3, 2);
    cout << "Matrix A" << endl;
    A.fill(5);
    A.print();
 
    cout << "Matrix B" << endl;
    B.fill(10);
    B.print();
 
    cout << "New matrix A" << endl;
    A.multiplication( B );
    A.print();
    
    return 0;
}