Создать класс квадратных матриц

#include <iostream>
#include <iomanip>
#include <random>
 
template<typename T>
class Matrix {
public:
    Matrix() : height(0), width(0), data(nullptr) {}
 
    Matrix(size_t size) : height(size), width(size), data(new T[height * width]{}) {}
 
    Matrix(size_t height, size_t width) : height(height), width(width), data(new T[height * width]{}) {}
 
    Matrix(const Matrix<T> &other) : height(other.height), width(other.width), data(new T[height * width]) {
        for (size_t i = 0, size = height * width; i < size; ++i) {
            data[i] = other.data[i];
        }
    }
 
    Matrix(Matrix<T> &&other) noexcept: Matrix() {
        std::swap(height, other.height);
        std::swap(width, other.width);
        std::swap(data, other.data);
    }
 
    Matrix<T> &operator=(Matrix<T> other) {
        std::swap(height, other.height);
        std::swap(width, other.width);
        std::swap(data, other.data);
        return *this;
    }
 
    virtual ~Matrix() {
        delete[] data;
    }
 
    virtual T &operator()(size_t row, size_t col) {
        return data[row * width + col];
    }
 
    virtual const T &operator()(size_t row, size_t col) const {
        return data[row * width + col];
    }
 
    virtual size_t getHeight() const {
        return height;
    }
 
    virtual size_t getWidth() const {
        return width;
    }
 
private:
    size_t height;
    size_t width;
    T *data;
};
 
// минор матрицы -- исходная матрица за вычетом строки и столбца
template<typename T>
class MinorMatrix : public Matrix<T> {
public:
    MinorMatrix(const Matrix<T> &source, std::size_t row, std::size_t col)
        : row(row), col(col), source(source) {}
 
    const T &operator()(std::size_t row, std::size_t col) const override {
        return source(row < MinorMatrix::row ? row : row + 1, col < MinorMatrix::col ? col : col + 1);
    }
 
    std::size_t getHeight() const override {
        return source.getHeight() - 1;
    }
 
    std::size_t getWidth() const override {
        return source.getWidth() - 1;
    }
 
private:
    std::size_t row;
    std::size_t col;
    const Matrix<T> &source;
};
 
template<typename T, typename S>
Matrix<T> operator*(Matrix<T> result, const S &scalar) {
    for (std::size_t i = 0, height = result.getHeight(); i < height; ++i) {
        for (std::size_t j = 0, width = result.getWidth(); j < width; ++j) {
            result(i, j) = result(i, j) * scalar;
        }
    }
    return result;
}
 
template<typename T>
Matrix<T> operator*(const Matrix<T> &a, const Matrix<T> &b) {
    if (a.getWidth() != b.getHeight()) {
        throw std::invalid_argument("the left matrix should have it's width equal to the right matrix height");
    }
    Matrix<T> result(a.getHeight(), b.getWidth());
    for (std::size_t i = 0; i < result.getHeight(); ++i) {
        for (std::size_t j = 0; j < result.getWidth(); ++j) {
            result(i, j) = 0;
            for (std::size_t k = 0; k < a.getWidth(); ++k) {
                result(i, j) += a(i, k) * b(k, j);
            }
        }
    }
    return result;
}
 
template<typename T>
std::ostream &operator<<(std::ostream &out, const Matrix<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, Matrix<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, typename Generator>
Matrix<T> generate(size_t height, size_t width, Generator generate) {
    Matrix<T> result(height, width);
    for (size_t i = 0; i < height; ++i) {
        for (size_t j = 0; j < height; ++j) {
            result(i, j) = generate(i, j);
        }
    }
    return result;
}
 
template<typename T>
T getDeterminant(const Matrix<T> &matrix) {
    if (matrix.getHeight() != matrix.getWidth()) {
        throw std::runtime_error("non-square matrices do not have determinants");
    }
    if (matrix.getHeight() == 1) {
        return matrix(0, 0);
    }
    if (matrix.getHeight() == 2) {
        return matrix(0, 0) * matrix(1, 1) - matrix(0, 1) * matrix(1, 0);
    }
    T result = 0;
    int sign = 1;
    for (std::size_t i = 0; i < matrix.getWidth(); ++i, sign = -sign) {
        result += sign * matrix(0, i) * getDeterminant(MinorMatrix(matrix, 0, i));
    }
    return result;
}
 
int main() {
    std::random_device rd;
    std::mt19937 re(rd());
    std::uniform_real_distribution<double> elementValueDistribution(-9, 9);
    auto randomElementGenerator = [&elementValueDistribution, &re](size_t i, size_t j)->double { return elementValueDistribution(re); };
 
    Matrix<double> randomMatrix = generate<double>(5, 5, randomElementGenerator);
    std::cout << "Random Matrix:\n" << randomMatrix << std::endl;
    std::cout << "Determinant: " << getDeterminant(randomMatrix) << std::endl;
    std::cout << "Multiplied by two:\n" << (randomMatrix * 2) << std::endl;
 
    Matrix<double> matrix(5);
    std::cin >> matrix;
    std::cout << "Matrix Read:\n" << matrix << std::endl;
    std::cout << "Determinant: " << getDeterminant(matrix) << std::endl;
    std::cout << "Multiplied by two:\n" << (matrix * 2) << std::endl;
 
    return 0;
}