C++ 类的赋值运算符'='重载

参考

什么类须要重载赋值运算符

先来看一个普通类的直接赋值。

#include <iostream>
using namespace std;

class person{
    int age;
public:
    person(const int& a=10):age(a){}  //构造函数
    ~person();  //析构函数
    void showAdd();   //打印age的地址
};

person::~person(){cout<<"析构\n";}

void person::showAdd() {cout <<hex<< &age<<endl;}

int main() {
    person a(11);
    person b;
    b = a;
    a.showAdd();
    b.showAdd();
    return 0;
}
/*
结果是：
0x7fffffffdc5c
0x7fffffffdc60
析构
析构
*/

这是这个程序的内存状况，一切都运行的很正常，不须要运算符重载。

看下边这个例子，这个类的构造函数须要申请（new）堆内存：

#include <iostream>
using namespace std;

class person{
    int* age;
public:
    person(const int& a=10);  //构造函数
    ~person();  //析构函数
    void showAdd();   //打印age的地址
    void show();  //打印age指向的值
    void set(const int& a){*age=a;}
};

person::person(const int& a) {age = new int(a);}

person::~person(){delete age; cout<<"析构\n";}

void person::showAdd() {cout << hex << age<<endl;}

void person::show() {cout<<*age<<endl;}

void f(person& a) {
    person b;
    b=a;
    a.show();
    b.show();
    a.showAdd();
    b.showAdd();
    //由于b是局部变量，因此进入main函数以前，b会自动调用析构函数
}

int main() {
    person a(11);
    f(a);
    cout<<"进入main函数\n";
    a.set(9);  //由于b已经释放过age指针，set应该会出错
    a.show();
    return 0;
}

运行结果以下：

这是这个程序进入 f() 函数时的内存状况，两个age指针指向同一块内存。

这是这个程序退出 f() 函数进入main函数的状况，由于b是局部变量，因此f()函数结束的时候，b会调用析构函数，释放age指向的堆内存。这时候a.set()就会发生错误，由于内存已经释放，无权修改内存里的值。就算没有set()函数，main函数结束的时候还会产生doublefree的错误，同一块内存被释放两次，C++文档说明这是个未定义行为，因此不一样编译器可能处理手段不同，个人gcc 7.4.0 居然没有报错。后来我又在网上的一些在线编译器实验一下，有的会报错，有的不会。

因此结论就是：类的构造函数须要申请堆内存的时候，咱们要进行赋值运算符的重载，下面讲如何重载。

如何重载赋值运算符

#include <iostream>
using namespace std;

class person{
    int* age;
public:
    person(const int& a=10);  //构造函数
    ~person();  //析构函数
    void showAdd();   //打印age的地址
    void show();  //打印age指向的值
    void set(const int& a){*age=a;}  //设置age指向的值

    void operator=(person const& e);  //重载赋值运算符
};

void person::operator=(person const& e)
{
    if(age) delete age;  //若是原先age申请过堆内存，要先释放
    int data = *(e.age);
    age = new int(data);
}

person::person(const int& a) {age = new int(a);}

person::~person(){delete age; cout<<"析构\n";}

void person::showAdd() {cout << hex << age<<endl;}

void person::show() {cout<<*age<<endl;}

void f(person& a) {
    person b;
    b = a;  //这时候b指向了一块新的空间
    a.show();
    b.show();
    a.showAdd();
    b.showAdd();
    //由于b是局部变量，因此进入main函数以前，b会自动调用析构函数
}

int main() {
    person a(11);
    f(a);
    cout<<"进入main函数\n";
    a.set(9);  //由于b释放的指针和age指向不同，set不会出错
    return 0;
}

程序运行正常，内存图以下：

注意上边我用的operator=返回值是void, 这样不能进行连续赋值，好比：person a = b = c; ,若想连续赋值，返回值要声明为 引用

person& person::operator=(person const& e)
{
    if(age) delete age; 
    int data = *(e.age);
    age = new int(data);
    return *this;
}

关于拷贝函数

再回看一下上边的代码，个人声明语句和赋值语句是分开的person b; b=a;,若是声明时赋值person b=a;，那么调用的函数就不是operator=了，而是拷贝函数

class person{
    int* age;
public:
    person(person const& e);  //这就是拷贝函数 
}

须要注意的是： 上边说的operator返回值有两种状况：void和引用，其实还有第三种，既然能返回引用那就还能返回值：

person person::operator=(person const& e)
{
    if(age) delete age; 
    int data = *(e.age);
    age = new int(data);
    return *this;
}

函数返回值的时候会临时构造一个person变量, 这个变量的age的指向和调用operator=的对象的age指向同样，也就是：

当operator=调用完以后，临时变量会调用析构函数，从而致使和上边同样的错误，doublefree。因此operator=的返回值最好是引用！