用动态分配空间和友元运算符重载写一个矩阵类,并实现矩阵的加法和乘法

好的，我可以为您解答这个问题。

首先，我们需要定义一个矩阵类，并使用动态分配内存的方式为其分配空间。以下是一个基本的矩阵类定义：

class Matrix {
private:
    int rows;  // 矩阵的行数
    int cols;  // 矩阵的列数
    int **data; // 存储矩阵元素的二维数组
public:
    Matrix(int rows, int cols);  // 构造函数
    ~Matrix();  // 析构函数
    friend Matrix operator+(const Matrix& m1, const Matrix& m2);  // 友元运算符重载：矩阵加法
    friend Matrix operator*(const Matrix& m1, const Matrix& m2);  // 友元运算符重载：矩阵乘法
};

在上述定义中，我们定义了一个矩阵类，其中包含了矩阵的行数、列数和存储元素的二维数组。我们还声明了两个友元运算符重载，用于实现矩阵的加法和乘法。

接下来，我们需要实现这个类的构造函数和析构函数：

Matrix::Matrix(int rows, int cols) {
    this->rows = rows;
    this->cols = cols;
    this->data = new int*[rows];
    for (int i = 0; i < rows; i++) {
        this->data[i] = new int[cols];
    }
}

Matrix::~Matrix() {
    for (int i = 0; i < rows; i++) {
        delete[] data[i];
    }
    delete[] data;
}

在构造函数中，我们使用动态分配内存的方式为矩阵分配空间。在析构函数中，我们需要释放已分配的内存。

接下来，我们需要实现矩阵加法和矩阵乘法的友元运算符重载。以下是这两个函数的实现：

Matrix operator+(const Matrix& m1, const Matrix& m2) {
    if (m1.rows != m2.rows || m1.cols != m2.cols) {
        throw std::invalid_argument("The matrices should have the same size.");
    }
    Matrix result(m1.rows, m1.cols);
    for (int i = 0; i < m1.rows; i++) {
        for (int j = 0; j < m1.cols; j++) {
            result.data[i][j] = m1.data[i][j] + m2.data[i][j];
        }
    }
    return result;
}

Matrix operator*(const Matrix& m1, const Matrix& m2) {
    if (m1.cols != m2.rows) {
        throw std::invalid_argument("The number of columns of the first matrix should be equal to the number of rows of the second matrix.");
    }
    Matrix result(m1.rows, m2.cols);
    for (int i = 0; i < m1.rows; i++) {
        for (int j = 0; j < m2.cols; j++) {
            int sum = 0;
            for (int k = 0; k < m1.cols; k++) {
                sum += m1.data[i][k] * m2.data[k][j];
            }
            result.data[i][j] = sum;
        }
    }
    return result;
}

在上述代码中，我们首先检查两个矩阵是否满足运算条件，如果不满足，则抛出异常。然后，我们使用嵌套循环来实现矩阵的加法和乘法。

最后，我们可以在主函数中测试我们的矩阵类：

int main() {
    Matrix m1(2, 3);
    m1.data[0][0] = 1;
    m1.data[0][1] = 2;
    m1.data[0][2] = 3;
    m1.data[1][0] = 4;
    m1.data[1][1] = 5;
    m1.data[1][2] = 6;

    Matrix m2(2, 3);
    m2.data[0][0] = 7;
    m2.data[0][1] = 8;
    m2.data[0][2] = 9;
    m2.data[1][0] = 10;
    m2.data[1][1] = 11;
    m2.data[1][2] = 12;

    Matrix m3 = m1 + m2;
    Matrix m4 = m1 * m2;

    return 0;
}

在上述代码中，我们首先创建了两个 2x3 的矩阵 m1 和 m2，并为其赋值。然后，我们使用加法和乘法运算符对这两个矩阵进行运算，并将结果保存到变量 m3 和 m4 中。