C++面向对象-15-赋值运算符的重载

男娘i 2023-07-03 04:36 15阅读 0赞

这一篇来学习赋值运算符重载，先来了解什么是赋值运算符，也就是单个等号（=）就是赋值运算符。什么时候，我们需要对赋值运算符进行重载呢？这里面离不开值拷贝的知识。

**1.C++编译器默认功能**

C++编译器至少给一个类添加4个函数  
1.默认构造函数（无参，函数体为空）  
2.默认析构函数（无参，函数体为空）  
3.默认拷贝构造函数，对属性进行值拷贝  
4.赋值运算符operator=，对属性进行值拷贝

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题

2.问题背景

这里先写一段代码，然后分析为什么会报错

上面代码解释：

1.写了有参构造和析构函数

2.有参构造中属性使用了在堆区开辟内存空间

3.类的成员变量定义为指针，所以test01()中cout输出，需要解引用，否则输出看到的是内存地址

4.在test01方法中p2 = p1 这行代码是赋值操作，所以p2的m\_Age输出值应该和p1一样，也就是18岁。

运行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE1NDE5NDY_size_16_color_FFFFFF_t_70][]

虽然结果打印出来，但是程序没有运行到main函数中暂停这行代码就崩溃，报了一个为加载xxx.pdb的错误。

错误分析如下

1）p2 = p1是赋值操作，发送了浅拷贝也就是p2中m\_Age的指针和p1中m\_Age的指针一模一样

2）回顾下C++类中构造函数和析构函数执行顺序，p1的构造执行，然后执行p1的析构函数

3）在p1执行析构函数，进行了内存回收，m\_Age这个指针设置为NULL

4）执行了p2 = p1操作，会执行p2的析构函数，也会释放内存

5）p1和p2都对同一个指针进行内存释放，第二个释放肯定会报错。

以上就是崩溃的错误分析过程。

为了避免这种方法，我们想在执行p2 = p1这行代码的时候，不想使用编译器默认的拷贝，而是在堆区重新开辟内存来指向m\_Age，也就是执行深拷贝，所以我们需要对等号（赋值运算）进行重载。

**3.赋值运算符重载**

因为暂时不知道重载函数返回类型是什么，我们先按照void写，来一个成员函数重载的实现方式

#include <iostream>
    using namespace std;
    
    class Person
    {
    public:
        //  把年龄这个属性写成指针
        int *m_Age;
    
        // 年龄开辟到堆区
        Person(int age)
        {
            m_Age = new int(age);  // new 来的对象都是一个内存地址
        }
    
        // 析构函数，程序员自己控制内存
        ~Person()
        {
            if (m_Age != NULL)
            {
                delete m_Age; // 删除所占内存，并置空
                m_Age = NULL;
            }
        }
    
        // 成员函数方法实现运算符重载
        void operator=(Person &p)
        {
            // 编译器默认是执行 m_Age = p.m_Age; 操作（浅拷贝）
            // 我们这里需判断，对象的属性是否在堆区存在，如果存在先释放内存，再进行深拷贝
            if (m_Age != NULL)
            {
                delete m_Age; // 删除所占内存，并置空
                m_Age = NULL;
            }
            // 深拷贝
            m_Age = new int(*p.m_Age); // 解引用拿出年龄，例如18岁
        }
    };
    
    void test01()
    {
        Person p1(18);
        Person p2(20);
    
        //赋值操作
        p2 = p1;
    
        cout << "p1的age为： " << *p1.m_Age << endl;
        cout << "p2的age为： " << *p2.m_Age << endl;
    
    }
    
    int main()
    {
        test01();
        system("pause");
        return 0;
    }

运行结果

![20200201230008612.png][]

看起来好像没有问题，但是我们test01()代码改成这样

void test01()
    {
        Person p1(18);
        Person p2(20);
        Person p3(30);
    
        //赋值操作
        p3 = p2 = p1;
    
        cout << "p1的age为： " << *p1.m_Age << endl;
        cout << "p2的age为： " << *p2.m_Age << endl;
        cout << "p3的age为： " << *p3.m_Age << endl;
    
    }

发现这行代码 p3 = p2 = p1会报错，但是我们肯定知道 如果是int 类型三个变量a,b,c 肯定支持 c = b = a这样的赋值操作，所以这里我们还需要思考赋值运算符重载函数的返回值是什么

#include <iostream>
    using namespace std;
    
    class Person
    {
    public:
        //  把年龄这个属性写成指针
        int *m_Age;
    
        // 年龄开辟到堆区
        Person(int age)
        {
            m_Age = new int(age);  // new 来的对象都是一个内存地址
        }
    
        // 析构函数，程序员自己控制内存
        ~Person()
        {
            if (m_Age != NULL)
            {
                delete m_Age; // 删除所占内存，并置空
                m_Age = NULL;
            }
        }
    
        // 成员函数方法实现运算符重载
        Person& operator=(Person &p)
        {
            // 编译器默认是执行 m_Age = p.m_Age; 操作（浅拷贝）
            // 我们这里需判断，对象的属性是否在堆区存在，如果存在先释放内存，再进行深拷贝
            if (m_Age != NULL)
            {
                delete m_Age; // 删除所占内存，并置空
                m_Age = NULL;
            }
            // 深拷贝
            m_Age = new int(*p.m_Age); // 解引用拿出年龄，例如18岁
            // 返回当前对象，支持链式编程
            return *this;
        }
    };
    
    void test01()
    {
        Person p1(18);
        Person p2(20);
        Person p3(30);
    
        //赋值操作
        p3 = p2 = p1;
    
        cout << "p1的age为： " << *p1.m_Age << endl;
        cout << "p2的age为： " << *p2.m_Age << endl;
        cout << "p3的age为： " << *p3.m_Age << endl;
    
    }
    
    int main()
    {
        test01();
        system("pause");
        return 0;
    }

解释一下，为什么这个函数重载需要返回一个引用，主要原因就是要支持这种链式编程风格。这里使用返回引用才是真正的本身，如果改成返回值，会报错，因为返回值的话，就是调用拷贝，是对象本身的一个副本。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE1NDE5NDY_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200201223600496.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE1NDE5NDY=,size_16,color_FFFFFF,t_70
[20200201230008612.png]: https://img-blog.csdnimg.cn/20200201230008612.png