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

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

相关问题

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

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

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

好的，下面是代码实现：

#include <iostream>
#include <vector>

using namespace std;

class Matrix {
private:
    int rows, cols;
    vector<vector<int>> data;

public:
    Matrix(int r, int c) {
        rows = r;
        cols = c;
        data.resize(rows, vector<int>(cols));
    }

    void set(int r, int c, int value) {
        data[r][c] = value;
    }

    int get(int r, int c) const {
        return data[r][c];
    }

    int getRows() const {
        return rows;
    }

    int getCols() const {
        return cols;
    }

    friend Matrix operator+ (const Matrix& m1, const Matrix& m2) {
        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;
    }

    friend Matrix operator- (const Matrix& m1, const Matrix& m2) {
        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;
    }

    friend Matrix operator* (const Matrix& m1, const Matrix& m2) {
        Matrix result(m1.rows, m2.cols);

        for (int i = 0; i < m1.rows; i++) {
            for (int j = 0; j < m2.cols; j++) {
                for (int k = 0; k < m1.cols; k++) {
                    result.data[i][j] += m1.data[i][k] * m2.data[k][j];
                }
            }
        }

        return result;
    }

    friend Matrix operator* (const Matrix& m, const int scalar) {
        Matrix result(m.rows, m.cols);

        for (int i = 0; i < m.rows; i++) {
            for (int j = 0; j < m.cols; j++) {
                result.data[i][j] = m.data[i][j] * scalar;
            }
        }

        return result;
    }

    friend Matrix operator* (const int scalar, const Matrix& m) {
        return m * scalar;
    }

    friend ostream& operator<< (ostream& os, const Matrix& m) {
        for (int i = 0; i < m.rows; i++) {
            for (int j = 0; j < m.cols; j++) {
                os << m.data[i][j] << " ";
            }
            os << endl;
        }

        return os;
    }
};

int main() {
    Matrix m1(2, 3);
    m1.set(0, 0, 1);
    m1.set(0, 1, 2);
    m1.set(0, 2, 3);
    m1.set(1, 0, 4);
    m1.set(1, 1, 5);
    m1.set(1, 2, 6);

    Matrix m2(2, 3);
    m2.set(0, 0, 7);
    m2.set(0, 1, 8);
    m2.set(0, 2, 9);
    m2.set(1, 0, 10);
    m2.set(1, 1, 11);
    m2.set(1, 2, 12);

    Matrix m3 = m1 + m2;
    cout << m3 << endl;

    Matrix m4 = m1 - m2;
    cout << m4 << endl;

    Matrix m5(3, 2);
    m5.set(0, 0, 1);
    m5.set(0, 1, 2);
    m5.set(1, 0, 3);
    m5.set(1, 1, 4);
    m5.set(2, 0, 5);
    m5.set(2, 1, 6);

    Matrix m6 = m1 * m5;
    cout << m6 << endl;

    Matrix m7 = m1 * 2;
    cout << m7 << endl;

    Matrix m8 = 2 * m1;
    cout << m8 << endl;

    return 0;
}

这个矩阵类实现了矩阵的基本运算，包括加减乘以及标量乘法。可以通过创建矩阵对象来进行运算，例如：

Matrix m1(2, 3);
m1.set(0, 0, 1);
m1.set(0, 1, 2);
m1.set(0, 2, 3);
m1.set(1, 0, 4);
m1.set(1, 1, 5);
m1.set(1, 2, 6);

Matrix m2(2, 3);
m2.set(0, 0, 7);
m2.set(0, 1, 8);
m2.set(0, 2, 9);
m2.set(1, 0, 10);
m2.set(1, 1, 11);
m2.set(1, 2, 12);

Matrix m3 = m1 + m2;
cout << m3 << endl;

这段代码创建了两个矩阵对象 m1 和 m2，然后用加法运算符实现了矩阵相加，结果存储在 m3 中，并打印出来。