C++三大函数(The Big Three)

C++三大函数：

• 析构函数
• 复制构造函数
• operator=

析构函数

函数模样：~S()

当一个对象超出作用域或执行delete的时候，析构函数就被调用。

复制构造函数

函数模样：S(const S& s)

以下情况，复制构造函数均会被调用：

• 声明的同时初始化：

  S s1 = s2;  //注意此时虽然出现=，但是不是调用operator=哦
  S s1(s2);
  

• 调用函数时使用按值传递（而不是按引用传递）

  void f(S s);
  S s1;
  f(s1);
  

• 通过值返回对象

  S f()
  {
      S s1;
      return s1;
  }
  

operator=

函数模样：const S& operator=(const S& s)

当=应用于两个已经构造的对象时，就调用复制赋值运算符operator=。

S s1;
s1 = s2;    //注意与S s1 = s2; 的区别

注意事项：

1. 三大函数不手动实现的时候，会使用默认的版本。比如operator=的默认版本会依次为数据成员复制，如果是基本数据类型自然没什么问题，但当数据成员含有指针的时候，operator的只会进行浅复制，即只是指针本身被复制，而不是指针所指向的内容被复制。见下例。

   class S
   {
       public:
       int *p;
       S(int x=0){p=new int(x);}
   };
   void f()
   {
       S s1(2), s2;
       S s3 = s1;
       s2 = s1;
       *s1.p=3;
       cout << *s1.p << ' '<< *s2.p << ' ' << *s3.p << endl;//3 3 3
   }
   

   很明显这不是我们想要的，我们想让不同的对象的值不互相影响，此时需要实现深复制，见下例。

2. #include <iostream>
   using namespace std;
   class S
   {
       public:
       int *p;
       S(int x=0){p=new int(x);}
       S(const S& rhs)
       {
           p = new int(*rhs.p);// 这里p存的是指向值的指针 
       }
       const S& operator=(const S& rhs)    //rhs=right-hand side，  rhs其实就是对象的别名，对引用操作就是对象本身操作 ，这里是s1 
       {
           if (this != &rhs)   //检查是否复制自身，是不是新的对象赋值 
               *p = *(rhs.p);
           return *this;   //返回对象本身，已经被修改过了 ,this调用完后，地址自动被释放了 
       }
      
   };
   int main() 
   {
       S s1(2), s2;
       S s3 = s1;   //这里使用的是拷贝函数 ，不同于operator=，只应用于已构造的对象，这里初次声明，还是使用的拷贝函数（复制构造函数） 
       s2 = s1;    //这里使用的operator=的重载 
       *(s1.p)=3;  //其实这里是对象.p先调用，然后再改指针指向的变量值 
       cout << *s1.p << ' '<< *s2.p << ' ' << *s3.p << endl;   //3 2 2
       cout << s1.p << ' '<< s2.p << ' ' << s3.p << endl;  //地址是不同的，对象也不同，实现了深度拷贝 
       return 0;
   }

   
   原文：https://zybuluo.com/chenyg32/note/7793