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

矩阵类是一种数据类型，用于表示二维数组。它可以用来表示各种数学问题，如线性代数、微积分等。为了实现矩阵的常用运算，我们可以使用友元函数。友元函数是一种特殊的函数，它可以访问类的私有成员。在矩阵类中，我们可以定义一些友元函数，如加法、减法、乘法等，来实现矩阵的常用运算。这些函数可以直接访问矩阵类的私有成员，如矩阵的行数、列数、元素等，从而实现矩阵的运算。通过使用友元函数，我们可以简化矩阵类的实现，提高代码的可读性和可维护性。

相关问题

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

矩阵类是一种数据类型，用于表示二维数组。它可以用来表示各种数学问题，如线性代数、微积分等。为了实现矩阵的常用运算，我们可以使用友元函数。友元函数是一个非成员函数，但它可以访问类的私有成员。这样，我们就可以在类外部定义一些函数，来实现矩阵的加、减、乘等运算。在定义矩阵类时，我们需要考虑矩阵的大小、元素类型、存储方式等问题。同时，我们还需要定义一些成员函数，如构造函数、析构函数、拷贝构造函数等，来管理矩阵的内存。最后，我们可以使用运算符重载来简化矩阵的操作，使其更加易用。

用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