Класс матриц

#pragma once
#include <cstdlib>
#include <iostream>
#include <ctime>
using namespace std;
 
class Matrix {
    int rows, cols;
    double** matr;
public:
    class Row {
        friend class Matrix;
    public:
        double& operator[](int col)
        {
            return parent.matr[row][col];
        }
    private:
        Row(Matrix& parent_, int row_) :
            parent(parent_),
            row(row_)
        {}
 
        Matrix& parent;
        int row;
    };
 
    Row operator[](int row)
    {
        return Row(*this, row);
    }
    Matrix();
    Matrix(int _rows, int _cols);
    Matrix(int _rows, int _cols, bool none);
    Matrix(const Matrix& other);
    ~Matrix();
    Matrix& operator=(const Matrix& other);
    Matrix operator+(const Matrix& other);
    Matrix operator-(const Matrix& other);
    Matrix operator*(const Matrix& other);
    friend ostream& operator<< (ostream& out, Matrix& object);
    double get_x(Matrix A, int row, int col);
    void set_x(Matrix& A, int row, int col, double value);
    void trans(Matrix& A);
};

#include "Matrix.h"
 
Matrix::Matrix()
{
    rows = cols = 0;
    matr = NULL;
}
 
Matrix::Matrix(int _rows, int _cols,bool none):rows(_rows),cols(_cols)
{
    srand(time(0));
    matr = new double* [rows];
    for (int i = 0; i < cols; i++)
    {
        matr[i] = new double[cols];
    }
 
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            matr[i][j] = rand()%100/10.0;
        }
    }
}
 
 
 
Matrix::Matrix(int _rows, int _cols) :rows(_rows), cols(_cols)
{
    matr = new double* [rows];
    for (int i = 0; i < cols; i++)
    {
        matr[i] = new double[cols];
    }
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            cin >> matr[i][j];
        }
    }
}
 
Matrix::Matrix(const Matrix& other)
{
    this->rows = other.rows;
    this->cols = other.cols;
    matr = new double* [rows];
    for (int i = 0; i < cols; i++)
    {
        matr[i] = new double[cols];
    }
    for (int i = 0; i < this->rows; i++)
    {
        for (int j = 0; j < this->cols; j++)
        {
            this->matr[i][j] = other.matr[i][j];
        }
    }
}
 
Matrix::~Matrix()
{
    for (int i = 0; i < rows; i++)
        delete[] matr[i];
    delete[] matr;
}
 
Matrix& Matrix::operator=(const Matrix& other)
{
    if (this == &other) return *this;
    this->rows = other.rows;
    this->cols = other.cols;
    matr = new double* [rows];
    for (int i = 0; i < cols; i++)
    {
        matr[i] = new double[cols];
    }
    for (int i = 0; i < this->rows; i++)
    {
        for (int j = 0; j < this->cols; j++)
        {
            this->matr[i][j] = other.matr[i][j];
        }
    }
    return *this;
}
 
Matrix Matrix::operator+(const Matrix& other)
{
    Matrix temp(this->rows, this->cols, 1);
    for (int i = 0; i < this->rows; i++)
    {
        for (int j = 0; j < this->cols; j++)
        {
            temp.matr[i][j] = this->matr[i][j] + other.matr[i][j];
        }
    }
    return temp;
}
 
Matrix Matrix::operator-(const Matrix& other)
{
    Matrix temp(this->rows, this->cols, 1);
    for (int i = 0; i < this->rows; i++)
    {
        for (int j = 0; j < this->cols; j++)
        {
            temp.matr[i][j] = this->matr[i][j] - other.matr[i][j];
        }
    }
    return temp;
}
 
Matrix Matrix::operator*(const Matrix& other)
{
    Matrix temp(this->rows, other.cols, 1);
    for (int i = 0; i < this->rows; i++)
    {
        for (int j = 0; j < this->cols; j++)
        {
            temp.matr[i][j] = 0;
            for (int k = 0; k < this->cols; k++)
            {
                temp.matr[i][j]+= this->matr[i][k] * other.matr[k][j];
            }
        }
    }
    return temp;
}
 
double Matrix::get_x(Matrix A,int row, int col)
{
    return A.matr[row][col];
}
 
void Matrix::set_x(Matrix& A, int row, int col, double value)
{
    A.matr[row][col] = value;
}
 
void Matrix::trans(Matrix& A)
{
    Matrix temp(A.cols, A.rows);
    for (int i = 0; i < A.cols; i++)
    {
        for (int j = 0; j < A.rows; j++)
        {
            temp.matr[i][j] = A.matr[j][i];
        }
    }
    A = temp;
}
 
ostream& operator<<(ostream& out, Matrix& object)
{   
    cout << endl;
    for (int i = 0; i < object.rows; i++)
    {
        for (int j = 0; j < object.cols; j++)
        {
            cout << object.matr[i][j] << " ";
        }
        cout << endl;
    }
    return out;
}