матрицы

#include <iostream>
using std::istream;
using std::ostream;
using std::cout;
using std::cin;
using std::endl;
 
#include <iomanip>
using std::setw;
 
#include <cstdlib>
using std::rand;
using std::srand;
 
#include <ctime>
using std::time;
 
class KMatrix {
 
    //перегрузка >>  операторов
    friend ostream &operator<<(ostream &, const KMatrix&);
 
private:
    int **myMatrix;
    int rows;
    int columns;
 
    int &getValue(int r, int c) {
        return this->myMatrix[r][c];
    }
 
    //этот класс является вспомогательным классом для перегрузки оператора  индексной матрицы [][]
    class KMatrixRow {
    public:
        KMatrixRow(KMatrix &k, int row) :
                km(k) {
            if (row < 0 || row >= k.rows) {
                x = 0;
            } else {
                x = row;
            }
        }
        int &operator[](int y) {
            return km.getValue(x, y);
        }
    private:
        KMatrix &km;
        int x; // номер строки
    };
 
public:
    KMatrix(int = 4, int = 4); //конструктор по умолчанию если не указан размер матрицы то создается матрица 10 на 10
    ~KMatrix(); //деструктор
 
    void setToZero(); //установить все значения матрицы  0
    void setRandValues(int = 0, int = 100); //заполнить матрицу случайными значениями
 
    //перегрузить индексный оператор.
    KMatrixRow operator[](int);
 
    //перегрузка оператора умножения
    //умножить матрицу на целочисленное значение
    KMatrix &operator*(const int &);
 
    //перегрузка оператора назначения
    KMatrix &operator=(KMatrix &);
 
};
 
//конструктор
KMatrix::KMatrix(int r, int c) :
        rows(r > 0 ? r : 4), columns(c > 0 ? c : 4) {
    myMatrix = new int*[r];
    for (int i = 0; i < rows; ++i) {
        myMatrix[i] = new int[columns];
    }
    setToZero();
}
 
//заполнить матрицу случайными значениями
void KMatrix::setRandValues(int from, int to) {
    srand(time(NULL));
    for (int i = 0; i < this->rows; ++i) {
        for (int j = 0; j < this->columns; ++j) {
            this->myMatrix[i][j] = (from + rand() % to);
        }
    }
}
 
//перегрузка оператора назначения
KMatrix &KMatrix::operator=(KMatrix &right) {
    if (&right != this) { // проверяем не присваиваем ли объект сам себе
        for (int i = 0; i < rows; ++i) { //освобождение памяти
            delete[] this->myMatrix[i]; //для каждой строки
        }
        delete[] this->myMatrix; //и матрицы
 
        this->rows = right.rows;
        this->columns = right.columns;
 
        //создать новую матрицу
        this->myMatrix = new int*[right.rows];
        for (int i = 0; i < this->rows; ++i) {
            this->myMatrix[i] = new int[right.columns];
        }
 
        //заполнение новой матрицы значениями правой матрицы
        for (int i = 0; i < this->rows; ++i) {
            for (int j = 0; j < this->columns; ++j) {
                this->myMatrix[i][j] = right[i][j];
            }
        }
    }
    return *this;
}
 
//перегрузка оператора умножения
KMatrix &KMatrix::operator*(const int &num) {
 
    for (int i = 0; i < this->rows; ++i) {
        for (int j = 0; j < this->columns; ++j) {
            this->myMatrix[i][j] = this->myMatrix[i][j]*num;
        }
    }
    return *this;
}
 
//перегрузка индексного оператора
KMatrix::KMatrixRow KMatrix::operator[](int x) {
    return KMatrixRow(*this, x);
}
 
//перегрузка outsream оператора;
ostream &operator<<(ostream &out, const KMatrix &km) {
    for (int i = 0; i < km.rows; ++i) {
        for (int j = 0; j < km.columns; ++j) {
            out << setw(4) << km.myMatrix[i][j];
        }
        out << endl;
    }
    return out;
}
 
//установить все элементы матрицы на 0
void KMatrix::setToZero() {
    for (int i = 0; i < this->rows; ++i) {
        for (int j = 0; j < this->columns; ++j) {
            this->myMatrix[i][j] = 0;
        }
    }
}
 
//деструктор
KMatrix::~KMatrix() {
}
 
int main(void) {
 
    //создать KMatrix 
    KMatrix km(5, 5);
 
    cout << "After initialising\n";
    cout << km;
 
    //установка значений
    km[0][0] = 10;
    km[0][1] = 15;
    km[2][3] = 33;
 
    //печать результатов
    cout << "\n\nAfter setting same elements";
    cout << "\n"<< km;
 
    //заполнить случайными значениями
    km.setRandValues();
 
    //распечатать матрицу со случайными значениями
    cout << "\n\nAfter setting random values";
    cout << "\n" << km;
 
    int a = 2;
    KMatrix newMatrix;
 
    newMatrix = km * a;
 
    cout << "\n\nAfter multiplying by int value (2)";
    cout << "\n" << newMatrix;
 
    cin.get();
    return 0;
}