Вычислить матричное выражение

#include <iostream>
#include <iomanip>
#include <utility>
 
// матрица, основанная на одномерном массиве данных
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]) {
        std::copy(other.data, other.data + width * height, data);
    }
 
    // оператор присваивания
    ArrayMatrix<T> &operator=(const ArrayMatrix<T> &other) {
        if (this != &other) {
            delete[] data;
            height = other.getHeight();
            width = other.getWidth();
            data = new T[height * width];
            copy(other, *this);
        }
        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 = std::move(other.height);
            this->width = std::move(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) {
        return data[row * width + col];
    }
 
    // константный оператор доступа к константным элементам матрицы
    const T &operator()(std::size_t row, std::size_t col) const {
        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 T>
ArrayMatrix<T> operator+(const ArrayMatrix<T> &a, const ArrayMatrix<T> &b) {
    if (a.getWidth() != b.getWidth() || a.getHeight() != b.getHeight()) {
        throw std::invalid_argument("matrices should be of the same dimension sizes");
    }
    ArrayMatrix<T> result(a.getHeight(), a.getWidth());
    for (std::size_t i = 0; i < a.getHeight(); ++i) {
        for (std::size_t j = 0; j < a.getWidth(); ++j) {
            result(i, j) = a(i, j) + b(i, j);
        }
    }
    return result;
}
 
// вычитание матриц
template<typename T>
ArrayMatrix<T> operator-(const ArrayMatrix<T> &a, const ArrayMatrix<T> &b) {
    if (a.getWidth() != b.getWidth() || a.getHeight() != b.getHeight()) {
        throw std::invalid_argument("matrices should be of the same dimension sizes");
    }
    ArrayMatrix<T> result(a.getHeight(), a.getWidth());
    for (std::size_t i = 0; i < a.getHeight(); ++i) {
        for (std::size_t j = 0; j < a.getWidth(); ++j) {
            result(i, j) = a(i, j) - b(i, j);
        }
    }
    return result;
}
 
 
 
int main() {
 
    std::size_t size;
    std::cin >> size;
 
    ArrayMatrix<double> a(size), b(size);
    std::cin >> a >> b;
 
    ArrayMatrix<double> c(size);
 
    for (std::size_t i = 0; i < size; ++i) {
        for (std::size_t j = 0; j < size; ++j) {
            c(i, j) = 1.0 / (i + j + 2);
        }
    }
 
    std::cout << "A:\n" << a
        << "B:\n" << b
        << "C:\n" << c
        << "A - B + C:\n" << (a - b + c);
 
    return 0;
}