---

#include <iostream>
#include <vector>

template <typename T>
class Matrix {
    public:
        size_t n = 0;
        size_t m = 0;
        std::vector<std::vector<T>> mat;
        Matrix(const std::vector<std::vector<T>> &_mat) {
            mat = _mat;
            n = mat.size();
            m = mat[0].size();
        }
        std::pair<size_t, size_t> size() const {
            return std::make_pair(n, m);
        }
        Matrix<T> operator+=(const Matrix<T> &A) {
            for (size_t i = 0; i < n; i++) {
                for (size_t j = 0; j < m; j++) {
                    mat[i][j] += A.mat[i][j];
                }
            }
            return *this;
        }
        Matrix<T> operator+(const Matrix<T> &A) const {
            std::vector<std::vector<T>> B_mat(n, std::vector<T>(m));
            Matrix<T> B = Matrix(B_mat);
            for (size_t i = 0; i < n; i++) {
                for (size_t j = 0; j < m; j++) {
                    B.mat[i][j] = A.mat[i][j] + mat[i][j];
                }
            }
            return B;
        }
        template <typename TT>
        Matrix<T> operator*=(TT x) {
            for (size_t i = 0; i < n; i++) {
                for (size_t j = 0; j < m; j++) {
                    mat[i][j] *= x;
                }
            }
            return *this;
        }
        template <typename TT>
        Matrix<T> operator*(TT x) const {
            std::vector<std::vector<T>> B_mat(n, std::vector<T>(m));
            Matrix<T> B = Matrix(B_mat);
            for (size_t i = 0; i < n; i++) {
                for (size_t j = 0; j < m; j++) {
                    B.mat[i][j] = mat[i][j] * x;
                }
            }
            return B;
        }
        Matrix<T> transpose() {
            std::vector<std::vector<T>> new_mat(m, std::vector<T>(n));
            for (size_t i = 0; i < m; i++) {
                for (size_t j = 0; j < n; j++) {
                    new_mat[i][j] = mat[j][i];
                }
            }
            mat = new_mat;
            size_t old_n = n;
            n = m;
            m = old_n;
            return *this;
        }
        Matrix<T> transposed() const {
            std::vector<std::vector<T>> new_mat(m, std::vector<T>(n));
            for (size_t i = 0; i < m; i++) {
                for (size_t j = 0; j < n; j++) {
                    new_mat[i][j] = mat[j][i];
                }
            }
            return Matrix(new_mat);
        }
};
template <typename T>
std::ostream& operator<<(std::ostream& out, const Matrix<T>& A) {
    size_t n = A.n;
    size_t m = A.m;
    for (size_t i = 0; i < n; i++) {
        for (size_t j = 0; j < m - 1; j++) {
            out << A.mat[i][j] << "\t";
        }
        out << A.mat[i][m - 1];
        if (i != n - 1) {
            out << "\n";
        }
    }
    return out;
}
D. Матрица - 4 ПИ С++ 23
Не решена
Ограничение времени	1.5 секунд
Ограничение памяти	64 Мб
Ввод	стандартный ввод или input.txt
Вывод	стандартный вывод или output.txt
Внесите следующие изменения в предыдущую программу:

Добавьте перегруженную версию оператора operator *= (const Matrix& other), умножающую текущую матрицу на other. Заметьте, что оператор должен вернуть ссылку на текущую модифицированную матрицу.
Добавьте реализацию константного оператора operator * (const Matrix& other), возвращающую произведение матриц.
Можете считать, что размеры матрицы не превосходят 
100
100, а значения — целые числа, не превосходящие 
100
100 по модулю.

Проверьте согласованность размеров перемножаемых матриц с помощью стандартной конструкции assert (https://en.cppreference.com/w/cpp/error/assert).