Написать функцию перемножения матриц

#include <iostream>
#include <random>
#include <utility>
#include <exception>
 
class Bad_operation :public std::exception
{
public:
    Bad_operation(const char* err) :std::exception(err) {}
};
 
class Matrix_base
{
protected:
    size_t dim1{};
    size_t dim2{};
    double* data{};
    Matrix_base() = default;
    Matrix_base(size_t, size_t, double*);
public:
    Matrix_base(const Matrix_base&) = default;
    Matrix_base& operator=(const Matrix_base&) = default;
};
 
class Matrix : public Matrix_base
{
public:
    Matrix(size_t, size_t);
    Matrix(const Matrix&);
    Matrix& operator=(const Matrix&);
    Matrix(Matrix&&) noexcept;
    Matrix& operator=(Matrix&&) noexcept;
    ~Matrix();
 
    size_t rows() const noexcept;
    size_t cols() const noexcept;
    void rand_int(int, int);
    double* operator[](size_t);
    const double* operator[](size_t) const;
    Matrix transpose() const;
    Matrix operator*(Matrix&&) const;
};
 
 
Matrix_base::Matrix_base(size_t dim1_, size_t dim2_, double* data_)
    : dim1(dim1_), dim2(dim2_), data(data_) {}
 
Matrix::~Matrix()
{
    delete data;
}
 
Matrix::Matrix(size_t dim1_, size_t dim2_)
    : Matrix_base(dim1_, dim2_, new double[dim1_ * dim2_]{}) {}
 
Matrix::Matrix(const Matrix& other)
    : Matrix(other.dim1, other.dim2)
{
    std::memcpy(data, other.data, dim1 * dim2);
}
 
Matrix& Matrix::operator=(const Matrix& other)
{
    return *this = Matrix(other);
}
 
Matrix::Matrix(Matrix&& other) noexcept
    : Matrix_base(std::exchange(other.dim1, 0), std::exchange(other.dim2, 0), std::exchange(other.data, nullptr)) {}
 
Matrix& Matrix::operator=(Matrix&& other) noexcept
{
    std::swap<Matrix_base, Matrix_base>(*this, other);
    return *this;
}
 
size_t Matrix::rows() const noexcept
{
    return dim1;
}
 
size_t Matrix::cols() const noexcept
{
    return dim2;
}
 
void Matrix::rand_int(int min, int max)
{
    std::random_device rd;
    std::uniform_int_distribution<int> uid{ min, max };
    for (size_t idx{}; idx < dim1*dim2; ++idx)
        data[idx] = uid(rd);
}
 
const double* Matrix::operator[](size_t row) const
{
    return data + dim2 * row;
}
 
double* Matrix::operator[](size_t row)
{
    return data + dim2 * row;
}
 
Matrix Matrix::transpose() const
{
    Matrix ret(dim2, dim1);
    for (size_t row{}; row < dim1; ++row)
        for (size_t col{}; col < dim2; ++col)
            ret[col][row] = (*this)[row][col];
    return ret;
}
 
Matrix Matrix::operator*(Matrix&& other) const
{
    if (dim2 != other.dim1) throw Bad_operation("Matrix::operator*");
    Matrix ret(dim1, other.dim2);
    for (size_t row{}; row < dim1; ++row)
        for (size_t col{}; col < other.dim2; ++col)
            for (size_t k{}; k < dim2; ++k)
                ret[row][col] += (*this)[row][k] * other[k][col];
    return ret;
}
 
std::ostream& operator<<(std::ostream& os, const Matrix& m)
{
    for (size_t row{}; row < m.rows(); ++row)
    {
        for (size_t col{}; col < m.cols(); ++col)
            os << m[row][col] << ' ';
        os << std::endl;
    }
    return os;
}
 
int main()
{
    try
    {
        Matrix a(5, 3);
        a.rand_int(0, 9);
        std::cout << a << std::endl;
        std::cout << a * a.transpose() << std::endl;
    }
    catch (Bad_operation& err)
    {
        std::cerr << err.what();
    }
    catch (...)
    {
        std::cerr << "oops";
    }
}