Очень непростая программа с класами!

#include <iostream>
 
class Matrix
{
public:
    Matrix(size_t size = 2):
    m_matrix(new double *[size]),
    m_size(size)
    {
        for (size_t i = 0; i < m_size; ++i)
        {
            m_matrix[i] = new double [m_size];
 
            for (size_t j = 0; j < m_size; ++j)
                m_matrix[i][j] = 0;
        }
    }
 
    Matrix(const Matrix &source):
    m_matrix(new double *[source.m_size]),
    m_size(source.m_size)
    {
        for (size_t i = 0; i < m_size; ++i)
        {
            m_matrix[i] = new double [m_size];
 
            for (size_t j = 0; j < m_size; ++j)
                m_matrix[i][j] = source.m_matrix[i][j];
        }
    }
 
    ~Matrix()
    {
        for (size_t i = 0; i < m_size; ++i)
            delete [] m_matrix[i];
 
        delete [] m_matrix;
    }
 
    void input()
    {
        for (size_t i = 0; i < m_size; ++i)
        {
            for (size_t j = 0; j < m_size; ++j)
            {
                std::cout << "matrix[" << i << "][" << j << "] = ";
                std::cin >> m_matrix[i][j];
            }
        }
    }
 
    void print() const
    {
        for (size_t i = 0; i < m_size; ++i)
        {
            for (size_t j = 0; j < m_size; ++j)
                std::cout << m_matrix[i][j] << "  ";
 
            std::cout << std::endl;
        }
    }
 
    Matrix &operator-=(const Matrix &right)
    {
        if (m_size == right.m_size)
            for (size_t i = 0; i < m_size; ++i)
                for (size_t j = 0; j < m_size; ++j)
                    m_matrix[i][j] -= right.m_matrix[i][j];
 
        return *this;
    }
 
    Matrix &operator*=(const Matrix &right)
    {
        Matrix result(m_size);
 
        if (m_size == right.m_size)
        {
            for (size_t i = 0; i < m_size; ++i)
                for (size_t j = 0; j < m_size; ++j)
                    for (size_t k = 0; k < m_size; ++k)
                        result.m_matrix[i][j] += m_matrix[i][k] * right.m_matrix[k][j];
 
            *this = result;
        }
 
        return *this;
    }
 
    Matrix &operator=(const Matrix &source)
    {
        if (this != &source)
        {
            if (m_size != source.m_size)
            {
                for (size_t i = 0; i < m_size; ++i)
                    delete [] m_matrix[i];
 
                delete [] m_matrix;
 
                m_size = source.m_size;
 
                m_matrix = new double *[m_size];
 
                for (size_t i = 0; i < m_size; ++i)
                    m_matrix[i] = new double [m_size];
            }
 
            for (size_t i = 0; i < m_size; ++i)
                for (size_t j = 0; j < m_size; ++j)
                    m_matrix[i][j] = source.m_matrix[i][j];
        }
 
        return *this;
    }
 
private:
    double **m_matrix;
    size_t m_size;
};
 
int main()
{
    Matrix m1(2), m2(2);
    
    m1.input();
    m2.input();
 
    Matrix m3 = m1, m4 = m1;
 
    m3 -= m2;
    m4 *= m2;
 
    m3.print();
    m4.print();
 
    return 0;
}