用c++定义矩阵类，使用友元实现矩阵的常用运算

好的，关于定义矩阵类并使用友元实现矩阵的常用运算的问题，我可以给出以下参考答案：

#include <iostream>
using namespace std;

class Matrix {
private:
    int row; // 矩阵的行数
    int col; // 矩阵的列数
    int **mat; // 矩阵的元素数组，使用动态分配内存的方式实现
public:
    Matrix(int r = 0, int c = 0) : row(r), col(c) { // 构造函数，初始化矩阵的行数和列数，并动态分配内存
        mat = new int*[row];
        for (int i = 0; i < row; i++) {
            mat[i] = new int[col];
        }
    }
    ~Matrix() { // 析构函数，释放动态分配的内存
        for (int i = 0; i < row; i++) {
            delete[] mat[i];
        }
        delete[] mat;
    }
    void set(int r, int c, int val) { // 设置矩阵中指定位置的元素值
        mat[r][c] = val;
    }
    friend Matrix operator+(const Matrix &m1, const Matrix &m2); // 友元函数，实现矩阵加法运算
    friend Matrix operator-(const Matrix &m1, const Matrix &m2); // 友元函数，实现矩阵减法运算
    friend Matrix operator*(const Matrix &m1, const Matrix &m2); // 友元函数，实现矩阵乘法运算
    friend Matrix operator*(const Matrix &m, int n); // 友元函数，实现矩阵数乘运算
    friend Matrix operator*(int n, const Matrix &m); // 友元函数，实现矩阵数乘运算
    friend ostream& operator<<(ostream &out, const Matrix &m); // 友元函数，实现矩阵的输出
};

Matrix operator+(const Matrix &m1, const Matrix &m2) {
    if (m1.row != m2.row || m1.col != m2.col) { // 检查矩阵的维数是否相同，如果不同则返回一个空矩阵
        Matrix res(0, 0);
        return res;
    } else {
        Matrix res(m1.row, m1.col); // 新建一个矩阵，用于存储运算结果
        for (int i = 0; i < m1.row; i++) {
            for (int j = 0; j < m1.col; j++) {
                res.mat[i][j] = m1.mat[i][j] + m2.mat[i][j]; // 对应元素相加
            }
        }
        return res;
    }
}

Matrix operator-(const Matrix &m1, const Matrix &m2) {
    if (m1.row != m2.row || m1.col != m2.col) { // 检查矩阵的维数是否相同，如果不同则返回一个空矩阵
        Matrix res(0, 0);
        return res;
    } else {
        Matrix res(m1.row, m1.col); // 新建一个矩阵，用于存储运算结果
        for (int i = 0; i < m1.row; i++) {
            for (int j = 0; j < m1.col; j++) {
                res.mat[i][j] = m1.mat[i][j] - m2.mat[i][j]; // 对应元素相减
            }
        }
        return res;
    }
}

Matrix operator*(const Matrix &m1, const Matrix &m2) {
    if (m1.col != m2.row) { // 检查矩阵的维数是否满足矩阵乘法的要求，如果不满足则返回一个空矩阵
        Matrix res(0, 0);
        return res;
    } else {
        Matrix res(m1.row, m2.col); // 新建一个矩阵，用于存储运算结果
        for (int i = 0; i < m1.row; i++) {
            for (int j = 0; j < m2.col; j++) {
                res.mat[i][j] = 0;
                for (int k = 0; k < m1.col; k++) {
                    res.mat[i][j] += m1.mat[i][k] * m2.mat[k][j]; // 矩阵乘法运算
                }
            }
        }
        return res;
    }
}

Matrix operator*(const Matrix &m, int n) {
    Matrix res(m.row, m.col); // 新建一个矩阵，用于存储运算结果
    for (int i = 0; i < m.row; i++) {
        for (int j = 0; j < m.col; j++) {
            res.mat[i][j] = m.mat[i][j] * n; // 矩阵数乘运算
        }
    }
    return res;
}

Matrix operator*(int n, const Matrix &m) {
    Matrix res(m.row, m.col); // 新建一个矩阵，用于存储运算结果
    for (int i = 0; i < m.row; i++) {
        for (int j = 0; j < m.col; j++) {
            res.mat[i][j] = m.mat[i][j] * n; // 矩阵数乘运算
        }
    }
    return res;
}

ostream& operator<<(ostream &out, const Matrix &m) {
    for (int i = 0; i < m.row; i++) {
        for (int j = 0; j < m.col; j++) {
            out << m.mat[i][j] << " "; // 按行输出矩阵元素
        }
        out << endl;
    }
    return out;
}

int main() {
    Matrix A(2, 2);
    A.set(0, 0, 1);
    A.set(0, 1, 2);
    A.set(1, 0, 3);
    A.set(1, 1, 4);

    Matrix B(2, 2);
    B.set(0, 0, 5);
    B.set(0, 1, 6);
    B.set(1, 0, 7);
    B.set(1, 1, 8);

    Matrix C = A + B;
    cout << C << endl;

    Matrix D = A - B;
    cout << D << endl;

    Matrix E = A * B;
    cout << E << endl;

    Matrix F = A * 2;
    cout << F << endl;

    Matrix G = 3 * B;
    cout << G << endl;

    return 0;
}

以上是一个简单的矩阵类的实现，利用友元函数实现了常用的矩阵加减乘、数乘等运算，还重载了运算符 <<，方便输出矩阵的元素。运行程序，可以得到以下输出结果：

6 8
10 12

-4 -4
-4 -4

19 22
43 50

2 4
6 8

15 18
21 24