计算机系大一实验报告：重载运算符Matrix类加法（拷贝构造函数、动态数组的解法）（完整代码已附文末）

勘误：

课本中有：

当函数具有类类型传值参数或者函数返回类类型值时，都需要调用拷贝构造函数，完成局部对象的初始化工作。

因此，调用拷贝构造函数的原因与析构函数删除释放空间无关；由于重载运算符时调用了类类型传值参数，所以应该提前编写拷贝构造函数。本篇详解系本人第一次创作，故难免出现纰漏和谬误，在此向大家表示歉意——2023年6月29日

以下为原文：

2、假设有两个均为3行3列的矩阵ml和m2，编写程序实现矩阵类Matrix，并重载运算符“＋”、“>>”和“<<”，使之能用于矩阵m1和m2相加、输入和输出。

书接上文，老师要求用动态数组写这道题所以我又重新写了一份……

读题可知，我们需要写一个Matrix类，需要重载+、>>、<<这三个运算符，于是大概的框架如下

Matrix类

{二维动态数组；

运算符重载；

}；

主函数
{重载后的输入、相加、输出；

}

由于老师要求使用动态数组，我们就不能像上一篇里面那样（具体哪样我也忘了）动态数组的使用需要空间的申请、释放，于是我们可以很自然地想到构造函数和析构函数

Matrix::~Matrix()
{
    for (int i = 0; i < 3; i++)
        delete[]p[i];
    delete[]p;
}
Matrix::Matrix()
{
    p = new double* [3];
    for (int i = 0; i < 3; i++)
        p[i] = new double[3];
}

这样我们就能很方便地在实例化对象的时候申请空间，在类的作用域结束时释放这些空间

然后顺着下来就是运算符的重载，就没有什么难度，这边直接给出相关代码

Matrix operator+(const Matrix& m1,const Matrix& m2)
{
    Matrix temp;
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            temp.p[i][j] = m1.p[i][j] + m2.p[i][j];
        }

    }
    return temp;
}
istream& operator>>(istream& in, Matrix& m1)
{
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
        {
            in >> m1.p[i][j];
        }
    return in;
}
ostream& operator<<(ostream& out, Matrix& m1)
{
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            out << m1.p[i][j] << "\t";
        }
        out << endl;
    }
    return out;
}

（有一说一，这比在类里面写一个Print/Scan函数用起来要方便多了）

这边说一下主要的重难点（其实也是我在写代码的过程中遇到的问题）：

1.动态二维数组的构建：原理是new一个每个元素都装着动态数组的动态数组。所以要用到两次指针double**p。new一个指针类型的数组（可能有一些表达上的差错），然后把这个数组里面的每个元素都指向一个动态数组；这边用for来实现。

Matrix::Matrix()
{
    p = new double* [3];
    for (int i = 0; i < 3; i++)
        p[i] = new double[3];
}

2：进行运算的时候要在“和”初始化的时候直接赋值，否则容易出现a、b已经析构删除了，才进行赋值的尴尬情况；这个时候则需要用到拷贝构造函数

3：由于是动态数组，在拷贝构造函数中注意要先为拷贝的那个类new一个空间，才能实现拷贝

本人也还是在学习过程中；第一次写讲解，词不达意，还请大家批评指正

有不懂的可以在评论区或者直接私信留言我，欢迎大家一起讨论学习

完整代码附文末，仅供参考

#include<iostream>
using namespace std;
class Matrix {
private:
    double**p;
    
public:
    Matrix();
    Matrix(const Matrix& a);
    friend Matrix operator+(const Matrix& m1, const Matrix& m2);
    friend istream& operator>>(istream& in, Matrix& m);
    friend ostream& operator<<(ostream& out, Matrix& m);
    ~Matrix() ;
};
Matrix::~Matrix()
{
    for (int i = 0; i < 3; i++)
        delete[]p[i];
    delete[]p;
}
Matrix::Matrix()
{
    p = new double* [3];
    for (int i = 0; i < 3; i++)
        p[i] = new double[3];
}
Matrix::Matrix(const Matrix& a)
{
    p = new double* [3];
    for (int i = 0; i < 3; i++)
        p[i] = new double[3];
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
            p[i][j] = a.p[i][j];
}
Matrix operator+(const Matrix& m1,const Matrix& m2)
{
    Matrix temp;
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            temp.p[i][j] = m1.p[i][j] + m2.p[i][j];
        }

    }
    return temp;
}
istream& operator>>(istream& in, Matrix& m1)
{
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
        {
            in >> m1.p[i][j];
        }
    return in;
}
ostream& operator<<(ostream& out, Matrix& m1)
{
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            out << m1.p[i][j] << "\t";
        }
        out << endl;
    }
    return out;
}
int main()
{
    Matrix a, b;
    cin >> a >> b;
    Matrix c = a + b;
    cout << c;   
}