Описать строки кода

#include <iostream>
#include <fstream>
using namespace std;
class Matrix {
public:
int size;
int* values;
Matrix(int);
void set_value(int val, int i, int j);
int get_value(int i, int j);
void input_by_row();
void output_by_row();
};
Matrix::Matrix(int a) {
size = a;
values = new int[a * a];
for (int i = 0; i < a * a; i++) values[i] = 0;
}
void Matrix::set_value(int val, int i, int j) {
values[(i - 1) * j - 1] = val;
}
int Matrix::get_value(int i, int j) {
return values[(i - 1) * j - 1];
}
void Matrix::input_by_row() {
int tmp = 0;
for (int i = 0; i < size; i++) {
for (int j = 0; j < i; j++)
values[tmp++] = 0;
for (int j = i; j < size; j++)
cin >> values[tmp++];
}
}
void Matrix::output_by_row() {
int tmp = 0;я
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++)
cout << values[tmp++] << ' ';
cout << endl;
}
}
Matrix difference(Matrix a, Matrix b) {
int t = a.size;
Matrix c(t);
for (int i = 0; i < t * t; i++)
c.values[i] = a.values[i] - b.values[i];
return c;
}
void compare(Matrix a, Matrix b) {
int t = a.size;
bool flag = true;
for (int i = 0; i < t * t; i++)
if (a.values[i] != b.values[i]) {
flag = false;
break;
}
26
if (flag) cout << "They are equal" << endl;
else cout << "They are not equal" << endl;
}
void replace(Matrix a, Matrix b) {
int t = a.size;
for (int i = 0; i < t * t; i++)
a.values[i] = b.values[i];
}
int main() {
int tval, ti, tj;
cout << "Please enter value for setting with its row and column indexes" <<
endl;
cin >> tval >> ti >> tj;
Matrix a(ti), b(tj);
a.set_value(tval , ti, tj);
cout << "Value: " << a.get_value(ti, tj) << endl;
cout << "Please enter matrix A" << endl;
a.input_by_row();
cout << "Matrix that you have just entered" << endl;
a.output_by_row();
cout << "Please enter matrix B" << endl;
b.input_by_row();
cout << "Differences of two matrixes:" << endl;
difference(a, b).output_by_row();
compare(a, b);
cout << "Replace of matrix:" << endl;
replace(a, b);
a.output_by_row();
ofstream myfile;
myfile.open("matrix.txt");
//save matrix a to file
myfile << a.size << ' ';
for (int i = 0; i < a.size; i++) {
for (int j = i; j < a.size; j++)
myfile << a.values[i * a.size + j] << ' ';
}
myfile.close();
cout << "Read matrix from a file:" << endl;
//read matrix from a file
ifstream ifile;
ifile.open("matrix.txt");
int tmp, tt;
ifile >> tmp;
for (int i = 0; i < tmp; i++) {
for (int j = 0; j < i; j++)
cout << "0 ";
for (int j = 0; j < a.size - i; j++) {
ifile >> tt;
cout << tt << ' ';
}
cout << endl;
}
ifile.close();
return 0;
}

#include <iostream>
#include <fstream>
#include <utility>
#include <iomanip>
#include <stdexcept>
 
// матрица, основанная на одномерном массиве данных
template<typename T>
class ArrayMatrix {
public:
 
    // конструктор по-умолчанию
    ArrayMatrix() : height(0), width(0), data(nullptr) {}
 
    // конструктор с двумя параметрами -- высота и ширина матрицы
    ArrayMatrix(std::size_t height, std::size_t width)
            : height(height), width(width), data(new T[height * width]{}) {}
 
    // конструктор с одним параметром, создающий квадратную матрицу
    explicit ArrayMatrix(std::size_t size)
            : height(size), width(size), data(new T[height * width]{}) {}
 
    // правило трёх:
    // конструктор копирования
    ArrayMatrix(const ArrayMatrix<T> &other)
            : height(other.height), width(other.width), data(new T[height * width]) {
        for (std::size_t i = 0, end = width * height; i < end; ++i) {
            data[i] = other.data[i];
        }
    }
 
    // оператор присваивания
    // наивная реализация
    ArrayMatrix<T> &operator=(const ArrayMatrix<T> &other) {
        if (this != &other) {
            T *newData = new T[height * width];
            delete[] data;
            height = other.getHeight();
            width = other.getWidth();
            data = newData;
            for (std::size_t i = 0, end = width * height; i < end; ++i) {
                data[i] = other.data[i];
            }
        }
        return *this;
    }
 
    // деструктор
    ~ArrayMatrix() {
        delete[] data;
    }
 
    // правило пяти:
    // move-конструктор
    ArrayMatrix(ArrayMatrix<T> &&other) noexcept
            : height(std::move(other.height)), width(std::move(other.width)),
              data(std::exchange(other.data, nullptr)) {}
 
    // move-оператор присваивания
    ArrayMatrix<T> &operator=(ArrayMatrix<T> &&other) noexcept {
        if (this != &other) {
            this->height = other.height;
            this->width = other.width;
            this->data = std::exchange(other.data, data);
        }
        return *this;
    }
 
    // количество строк матрицы
    std::size_t getHeight() const {
        return height;
    }
 
    // количество столбцов матрицы
    std::size_t getWidth() const {
        return width;
    }
 
    // оператор доступа к элементам матрицы
    T &operator()(std::size_t row, std::size_t col) {
        // проверка на правильность индексов
        if (row > height || col > height) {
            throw std::invalid_argument("matrix indexes out of range");
        }
        return data[row * width + col];
    }
 
    // константный оператор доступа к константным элементам матрицы
    const T &operator()(std::size_t row, std::size_t col) const {
        // проверка на правильность индексов
        if (row > height || col > height) {
            throw std::invalid_argument("matrix indexes out of range");
        }
        return data[row * width + col];
    }
 
private:
    std::size_t height; // количество строк
    std::size_t width; // количество столбцов
    T *data; // матрица в виде одномерного массива
};
 
// оператор вывода матрицы на экран
template<typename T>
std::ostream &operator<<(std::ostream &out, const ArrayMatrix<T> &m) {
    for (std::size_t i = 0; i < m.getHeight(); ++i) {
        for (std::size_t j = 0; j < m.getWidth(); ++j) {
            out << std::fixed << std::setprecision(2) << std::setw(7) << m(i, j);
        }
        out << std::endl;
    }
    return out;
}
 
// оператор ввода матрицы из потока
template<typename T>
std::istream &operator>>(std::istream &in, ArrayMatrix<T> &m) {
    for (std::size_t i = 0; i < m.getHeight(); ++i) {
        for (std::size_t j = 0; j < m.getWidth(); ++j) {
            in >> m(i, j);
        }
    }
    return in;
}
 
// вычитание матриц различных типов
// тип результата вычисляется во время компиляции
template<typename A, typename B, typename R = decltype(A(0) - B(0))>
ArrayMatrix<R> operator-(const ArrayMatrix<A> &a, const ArrayMatrix<B> &b) {
    if (a.getHeight() != b.getHeight() || a.getWidth() != b.getWidth()) {
        throw std::invalid_argument("matrices must be of equal sizes to add");
    }
    ArrayMatrix<R> result(a.getHeight(), a.getWidth());
    for (std::size_t i = 0; i < result.getHeight(); ++i) {
        for (std::size_t j = 0; j < result.getWidth(); ++j) {
            result(i, j) = a(i, j) - b(i, j);
        }
    }
    return result;
}
 
int main() {
    std::size_t height, width;
    std::cin >> height >> width;
 
    // создание первой матрицы
    ArrayMatrix<int> first(height, width);
 
    std::size_t row, col;
    std::cin >> row >> col;
    // доступ к отдельному элементу по индексу (индексы идут с нуля!)
    // запись
    std::cin >> first(row, col);
    // чтение
    std::cout << "first[" << row << "][" << col << "] = " <<  first(row, col) << std::endl;
 
    // чтение значений матрицы с консоли
    std::cin >> first;
    // вывод на экран
    std::cout << "First:\n" << first << std::endl;
 
    // создание второй матрицы
    ArrayMatrix<int> second(height, width);
 
    // чтение значений из второй матрицы
    std::cin >> second;
    // вывод второй матрицы на экран
    std::cout << "Second:\n" << second << std::endl;
 
    // рассчёт разности матриц и помещение результата в новую матрицу
    ArrayMatrix<int> difference = first - second;
    // вывод разности матриц на экран
    std::cout << "Difference:\n" << difference << std::endl;
 
    // открытие файла на запись
    std::ofstream out("../main.cpp.cout");
    // запись в файл матрицы - разницы
    out << difference;
    // закрытие файла
    out.close();
 
    // открытие файла на чтение
    std::ifstream in("../main.cpp.cout");
    // чтение матрицы из файла
    in >> difference;
    // закрытие файла
    in.close();
    std::cout << "Read matrix:\n" << difference << std::endl;
 
    // присваивание одной матрицы другой
    first = second;
    // проверочный вывод
    std::cout << "First == Second:\n" << first;
 
 
    return 0;
}