C++中的赋值运算符重载函数（operator=）

朴灿烈づ我的快乐病毒、 2023-10-05 09:01 48阅读 0赞

本文主要介绍C++中的赋值运算符重载函数（operator=）的相关知识。

## 1. 概述 ##

### 1.1 why ###

首先介绍为什么要对赋值运算符“=”进行重载。某些情况下，当我们编写一个类的时候,，并不需要为该类重载“=”运算符，因为编译系统为每个类提供了默认的赋值运算符“=”，使用这个默认的赋值运算符操作类对象时，该运算符会把这个类的所有数据成员都进行一次赋值操作。例如有如下类：

class A
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
         {
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
         
         
          public:
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
             
         
         
          int a;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
             
         
         
          int b;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
             
         
         
          int c;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
         };

那么对这个类的对象进行赋值时，使用默认的赋值运算符是没有问题的。示例代码（operator\_test4.cpp）如下：

#include <iostream>
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
          
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
         
         
          using 
         
         
          namespace 
         
         
          std;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
          
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
         
         
          class ClassA
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
         {
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
         
         
          public:
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             
         
         
          int a;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             
         
         
          int b;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             
         
         
          int c;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
         };
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
          
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
         
         
          int main()
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
         {
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             ClassA obj1;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             obj1.a = 
         
         
          1;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             obj1.b = 
         
         
          2;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             obj1.c = 
         
         
          3;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
          
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             ClassA obj2;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             obj2 = obj1;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
          
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             
         
         
          cout << 
         
         
          "obj2.a is: " << obj2.a << 
         
         
          endl;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
          
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             
         
         
          return 
         
         
          0;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
         }

编译并执行上述代码，结果如下：

![70][]

从上述结果能够知道：通过使用系统默认的赋值运算符“=”，可以让对象obj2中的所有数据成员的值与对象obj1相同。这种情况下，编译系统提供的默认赋值运算符可以正常使用。

但是，在下面的示例中，使用编译系统默认提供的赋值运算符，就会出现问题了。示例代码（operator\_test5.cpp）如下：

编译并运行上述代码，结果如下：

![70 1][]

上述错误信息说明：当obj1和obj2进行析构的时候，由于重复释放了一块内存，导致程序崩溃报错。在这种情况下，就需要我们重载赋值运算符“=”了。

## 2. 示例代码 ##

###  ###

### 2.1 示例代码1 ###

我们修改一下前面出错的代码示例，现编写一个包含赋值运算符重载函数的类，代码（operator\_test5.cpp）如下：

#include <iostream>
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
         
         
          #include <string.h>
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
          
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
         
         
          using 
         
         
          namespace 
         
         
          std;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
          
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
         
         
          class ClassA
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
         {
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
         
         
          public:
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             ClassA()
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             {
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
             
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             }
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             ClassA(
         
         
          const 
         
         
          char* pszInputStr)
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             {
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
                 pszTestStr = 
         
         
          new 
         
         
          char[
         
         
          strlen(pszInputStr) + 
         
         
          1];
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
                 
         
         
          strncpy(pszTestStr, pszInputStr, 
         
         
          strlen(pszInputStr) + 
         
         
          1);
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             }
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
             
         
         
          virtual ~ClassA()
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             {
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
                 
         
         
          delete pszTestStr;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             }
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
             
         
         
          // 赋值运算符重载函数
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             ClassA& 
         
         
          operator=(
         
         
          const ClassA& cls)
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             {
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
                 
         
         
          // 避免自赋值
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
                 
         
         
          if (
         
         
          this != &cls)
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
                 {
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
                     
         
         
          // 避免内存泄露
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
                     
         
         
          if (pszTestStr != 
         
         
          NULL)
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
                     {
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
                         
         
         
          delete pszTestStr;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
                         pszTestStr = 
         
         
          NULL;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
                     }
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
          
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
                     pszTestStr = 
         
         
          new 
         
         
          char[
         
         
          strlen(cls.pszTestStr) + 
         
         
          1];
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
                     
         
         
          strncpy(pszTestStr, cls.pszTestStr, 
         
         
          strlen(cls.pszTestStr) + 
         
         
          1);
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
                 }
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
                 
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
                 
         
         
          return *
         
         
          this;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             }
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
             
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
         
         
          public:
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
             
         
         
          char* pszTestStr;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
         };
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
          
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
         
         
          int main()
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
         {
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
             
         
         
          ClassA obj1("liitdar");
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
          
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             ClassA obj2;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             obj2 = obj1;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
          
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
             
         
         
          cout << 
         
         
          "obj2.pszTestStr is: " << obj2.pszTestStr << 
         
         
          endl;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
             
         
         
          cout << 
         
         
          "addr(obj1.pszTestStr) is: " << &obj1.pszTestStr << 
         
         
          endl;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
             
         
         
          cout << 
         
         
          "addr(obj2.pszTestStr) is: " << &obj2.pszTestStr << 
         
         
          endl;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
          
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
             
         
         
          return 
         
         
          0;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
         }

编译并运行上述代码，结果如下：

![70 2][]

通过上述结果能够看到，我们利用赋值运算符重载函数，解决了对象赋值的情况下，析构函数中过程中多次释放同一块内存的问题。

对于上述代码，有以下几点需要说明：

*  当为一个类的对象赋值（可以用本类对象为其赋值，也可以用其它类型的值为其赋值）时，该对象（如本例的obj2）会调用该类的赋值运算符重载函数，进行具体的赋值操作。如上述代码中的“obj2 = obj1;”语句，用obj1为obj2赋值，则会由obj2调用ClassA类的赋值运算符重载函数。
 *  语句“ClassA obj2;  
    obj2 = obj1;“  
    和语句“ClassA obj2 = obj1;”在调用函数上是有区别的：前者第一句是对象obj2的声明及定义，调用类ClassA的无参构造函数，所以“obj2 = obj1;”一句是在对象obj2已经存在的情况下，用obj1来为obj2赋值，调用的是赋值运算符重载函数；而后者，是用obj1来初始化obj2，调用的是拷贝构造函数。关于拷贝构造函数的语句样式为“ClassA(const ClassA& cls)”，关于拷贝构造函数的内容，此处不进行详述。
 *  当程序没有显式地提供一个以“本类或本类的引用”为参数的赋值运算符重载函数时，编译器会自动生成一个默认的赋值运算符重载函数。

###  ###

### 2.2 示例代码2 ###

示例代码（operator\_test6.cpp）如下：

#include<iostream>
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
         
         
          #include<string>
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
          
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
         
         
          using 
         
         
          namespace 
         
         
          std;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
          
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
         
         
          class Data
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
         {
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
         
         
          private:
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
             
         
         
          int data;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
             
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
         
         
          public:
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
             
         
         
          // 构造函数
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             Data()
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             {
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             };
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
             
         
         
          // 构造函数
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             Data(
         
         
          int _data):data(_data)
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             {
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
                 
         
         
          cout << 
         
         
          "This is constructor" << 
         
         
          endl;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             }
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
             
         
         
          // 赋值运算符重载函数
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             Data& 
         
         
          operator=(
         
         
          const 
         
         
          int _data)
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             {
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
                 
         
         
          cout << 
         
         
          "This is operator=(int _data)" << 
         
         
          endl;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
                 data = _data;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
                 
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
                 
         
         
          return *
         
         
          this;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             }
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
         };
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
          
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
         
         
          int main()
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
         {
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
             
         
         
          // 调用构造函数
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
             
         
         
          Data data1(1);
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             Data data2, data3;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
             
         
         
          // 调用赋值运算符重载函数
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             data2 = 
         
         
          1;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
             
         
         
          // 调用默认的赋值运算符重载函数
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
             data3 = data2;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
             
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
             
         
         
          return 
         
         
          0;
        
        
         
       
       
        
       
       
       
        
        
        
         
       
       
        
       
       
        
        
        
         
          
         
         }

编译并执行上述代码，结果如下：

![70 3][]

上述结果说明：“data2 = 1;”语句调用了我们提供的以int型参数（而非本类或本类的引用）为形参的赋值运算符重载函数，而“data3 = data2;”的成功执行，说明该语句调用了编译器提供的默认的赋值运算符重载函数。

如果将上述代码中赋值运算符重载函数去掉，重新编译执行，结果如下：

![70 4][]

上述结果说明，当用一个非类A的值（如上面的int类型值）为类A的对象赋值时：

*  如果检测到构造函数和赋值运算符重载函数同时存在，则会调用赋值运算符重载函数；
 *  如果检测到的构造函数，就会调用这个构造函数。

## 3. 总结 ##

综合上述示例内容，我们可以知道针对以下情况，需要显式地提供赋值运算符重载函数（即自定义赋值运算符重载函数）：

*  用非类A类型的值为类A的对象赋值时（当然，这种情况下我们可以不提供相应的赋值运算符重载函数，而只提供相应的构造函数，如**更改后**的示例代码2）。
 *  当用类A类型的值为类A的对象赋值，且类A的数据成员中含有指针的情况下，必须显式提供赋值运算符重载函数（如示例代码1）。

[70]: https://img-blog.csdn.net/20180611184315643?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpaXRkYXI=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 1]: https://img-blog.csdn.net/20180611190943392?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpaXRkYXI=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 2]: https://img-blog.csdn.net/20180611192042370?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpaXRkYXI=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 3]: https://img-blog.csdn.net/20180611194824856?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpaXRkYXI=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 4]: https://img-blog.csdn.net/20180611195432884?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpaXRkYXI=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70