Описать класс Матрица. Реализовать весь набор операций над матрицами

#pragma once
class Matrix
{
private:
    int** _matrix;
    size_t _rows;
    size_t _columns;
 
public:
    Matrix(size_t rows, size_t columns);
    Matrix(const Matrix& matrix);
    ~Matrix();
 
    size_t GetRows();
    size_t GetColumns();
    void   Print();
    void   AllocMemory();
    void   CopyElementsInRow(const Matrix& matrix, size_t i);
    void   CopyMatrix(const Matrix& matrix);
    void   FillAllocatedMemory();
    void   Set(size_t row, size_t columns, int value);
    void   GetSumRows(const Matrix& firstMatrix, const Matrix& secondMatrix, size_t i);
    int    Get(size_t row, size_t columns) const;
 
public:
    Matrix& operator=(const Matrix& matrix);
    friend Matrix  operator+(const Matrix& firstMatrix, const Matrix& secondMatrix);
};
 
Matrix operator+(const Matrix& firstMatrix, const Matrix& secondMatrix);

#include <iostream>
#include "Matrix.h"
 
size_t Matrix::GetRows()
{
    return _rows;
}
 
size_t Matrix::GetColumns()
{
    return _columns;
}
 
void Matrix::AllocMemory()
{
    _matrix = new int* [_rows];
 
    for (size_t i = 0; i < _rows; ++i)
        _matrix[i] = new int[_columns];
}
 
 
void Matrix::Print()
{
    for (int i = 0; i < _rows; i++)
    {
        for (int j = 0; j < _columns; j++)
        {
            std::cout << _matrix[i][j] << " ";
        }
        std::cout << std::endl;
    }
}
 
void Matrix::CopyElementsInRow(const Matrix&m, unsigned int i)
{
    for (unsigned int j = 0; j < _columns; ++j)
        _matrix[i][j] = m._matrix[i][j];
}
 
void Matrix::CopyMatrix(const Matrix& matrix)
{
    if (matrix._columns != _columns || matrix._rows != _rows)
        throw std::exception("Wrong sizes");
 
    for (size_t i = 0; i < _rows; ++i)
        CopyElementsInRow(matrix, i);
}
 
void Matrix::FillAllocatedMemory()
{
    for (size_t i = 0; i < _rows; ++i)
        memset(_matrix[i], 0, _columns * sizeof(int));
}
 
void Matrix::Set(size_t row, size_t columns, int value)
{
    _matrix[row][columns] = value;
}
 
int Matrix::Get(size_t row, size_t columns) const
{
    return _matrix[row][columns];
}
 
Matrix::Matrix(size_t rows, size_t columns)
{
    this->_rows = rows; this->_columns = columns;
 
    AllocMemory();
    FillAllocatedMemory();
}
 
Matrix::Matrix(const Matrix& matrix)
{
    _rows = matrix._rows;
    _columns = matrix._columns;
 
    AllocMemory();
    CopyMatrix(matrix);
}
 
Matrix::~Matrix()
{
    for (size_t i = 0; i < _rows; ++i)
        delete[] _matrix[i];
 
    delete[] _matrix;
}
 
Matrix& Matrix::operator=(const Matrix& matrix)
{
    CopyMatrix(matrix);
    return *this;
}
 
void Matrix::GetSumRows(const Matrix& firstMatrix, const Matrix& secondMatrix, size_t i)
{
    for (size_t j = 0; j < GetColumns(); ++j)
        Set(i, j, firstMatrix.Get(i, j) + secondMatrix.Get(i, j));
}
 
Matrix operator+(const Matrix& firstMatrix, const Matrix& secondMatrix)
{
    if (firstMatrix._rows != secondMatrix._rows || firstMatrix._columns != secondMatrix._columns)
    {
        throw std::exception("Wrong sizes");
    }
 
    Matrix matrix(firstMatrix._rows, firstMatrix._columns);
 
    for (size_t i = 0; i < matrix._rows; ++i)
        matrix.GetSumRows(firstMatrix, secondMatrix, i);
 
    return matrix;
}

CopyElementsInRow