一. 什么是拷贝构造函数

  1. class CExample {
  2. private:
  3.     int a;
  4. public:
  5.     //构造函数
  6.     CExample(int b)
  7.     { a = b;}
  9.     //拷贝构造函数
  10.     CExample(const CExample& C)
  11.     {
  12.         a = C.a;
  13.     }
  14. };

CExample(const CExample& C) 就是我们自定义的拷贝构造函数。可见，拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它必须的一个参数是本类型的一个引用变量。

二、什么时候使用拷贝构造函数

在C++中，下面三种对象需要调用拷贝构造函数！

1. 对象以值传递的方式传入函数参数

  1. class CExample 
  2. {
  3. private:
  4.  int a;
  6. public:
  7.  //构造函数
  8.  CExample(int b)
  9.  { 
  10.   a = b;
  11.   cout<<"creat: "<<a<<endl;
  12.  }
  14.  //拷贝构造
  15.  CExample(const CExample& C)
  16.  {
  17.   a = C.a;
  18.   cout<<"copy"<<endl;
  19.  }
  20. };
  22. //全局函数，传入的是对象
  23. void g_Fun(CExample C)
  24. {
  25.  cout<<"test"<<endl;
  26. }
  28. int main()
  29. {
  30.  CExample test(1);
  31.  //传入对象
  32.  g_Fun(test);
  34.  return 0;
  35. }

调用g_Fun()时，会产生以下几个重要步骤：
(1).test对象传入形参时，会先会产生一个临时变量，就叫 C 吧。
(2).然后调用拷贝构造函数把test的值给C。 整个这两个步骤有点像：CExample C(test);
(3).等g_Fun()执行完后, 析构掉 C 对象。

2. 对象以值传递的方式从函数返回

  1. class CExample 
  2. {
  3. private:
  4.  int a;
  6. public:
  7.  //构造函数
  8.  CExample(int b)
  9.  { 
  10.   a = b;
  11.  }
  13.  //拷贝构造
  14.  CExample(const CExample& C)
  15.  {
  16.   a = C.a;
  17.   cout<<"copy"<<endl;
  18.  }
  20.      void Show ()
  21.      {
  22.          cout<<a<<endl;
  23.      }
  24. };
  26. //全局函数
  27. CExample g_Fun()
  28. {
  29.  CExample temp(0);
  30.  return temp;
  31. }
  33. int main()
  34. {
  35.  g_Fun();
  36.  return 0;
  37. }

当g_Fun()函数执行到return时，会产生以下几个重要步骤：
(1). 先会产生一个临时变量，就叫XXXX吧。
(2). 然后调用拷贝构造函数把temp的值给XXXX。整个这两个步骤有点像：CExample XXXX(temp);
(3). 在函数执行到最后先析构temp局部变量。
(4). 等g_Fun()执行完后再析构掉XXXX对象。

3. 对象需要通过另外一个对象进行初始化；

  1. CExample A(100);
  2. CExample B = A; 
  3. // CExample B(A);

后两句都会调用拷贝构造函数。

三、什么是浅拷贝？深拷贝？

1.浅拷贝

所谓浅拷贝，指的是在对象复制时，只对对象中的数据成员进行简单的赋值，默认拷贝构造函数执行的也是浅拷贝。大多情况下“浅拷贝”已经能很好地工作了，但是一旦对象存在了动态成员，那么浅拷贝就会出问题了，让我们考虑如下一段代码：

  1. class Rect
  2. {
  3. public:
  4.     Rect()      // 构造函数，p指向堆中分配的一空间
  5.     {
  6.         p = new int(100);
  7.     }
  8.     ~Rect()     // 析构函数，释放动态分配的空间
  9.     {
  10.         if(p != NULL)
  11.         {
  12.             delete p;
  13.         }
  14.     }
  15. private:
  16.     int width;
  17.     int height;
  18.     int *p;     // 一指针成员
  19. };
  21. int main()
  22. {
  23.     Rect rect1;
  24.     Rect rect2(rect1);   // 复制对象
  25.     return 0;
  26. }

在这段代码运行结束之前，会出现一个运行错误。原因就在于在进行对象复制时，对于动态分配的内容没有进行正确的操作。我们来分析一下：
在运行定义rect1对象后，由于在构造函数中有一个动态分配的语句，因此执行后的内存情况大致如下：
image.png
在使用rect1复制rect2时，由于执行的是浅拷贝，只是将成员的值进行赋值，这时 rect1.p = rect2.p，也即这两个指针指向了堆里的同一个空间，如下图所示：
image.png
当然，这不是我们所期望的结果，在销毁对象时，两个对象的析构函数将对同一个内存空间释放两次，这就是错误出现的原因。我们需要的不是两个p有相同的值，而是两个p指向的空间有相同的值，解决办法就是使用“深拷贝”。

2.深拷贝

在“深拷贝”的情况下，对于对象中动态成员，就不能仅仅简单地赋值了，而应该重新动态分配空间，如上面的例子就应该按照如下的方式进行处理：

  1. class Rect
  2. {
  3. public:
  4.     Rect()      // 构造函数，p指向堆中分配的一空间
  5.     {
  6.         p = new int(100);
  7.     }
  8.     Rect(const Rect& r)
  9.     {
  10.         width = r.width;
  11.         height = r.height;
  12.         p = new int;    // 为新对象重新动态分配空间
  13.         *p = *(r.p);
  14.     }
  15.     ~Rect()     // 析构函数，释放动态分配的空间
  16.     {
  17.         if(p != NULL)
  18.         {
  19.             delete p;
  20.         }
  21.     }
  22. private:
  23.     int width;
  24.     int height;
  25.     int *p;     // 一指针成员
  26. };

image.png
此时rect1的p和rect2的p各自指向一段内存空间，但它们指向的空间具有相同的内容，这就是所谓的“深拷贝”。

四、防止默认拷贝

通过对对象复制的分析，我们发现对象的复制大多在进行“值传递”时发生，这里有一个小技巧可以防止按值传递——声明一个私有拷贝构造函数。甚至不必去定义这个拷贝构造函数，这样因为拷贝构造函数是私有的，如果用户试图按值传递或函数返回该类对象，将得到一个编译错误，从而可以避免按值传递或返回对象。

  1. // 防止按值传递
  2. class CExample 
  3. {
  4. private:
  5.     int a;
  7. public:
  8.     //构造函数
  9.     CExample(int b)
  10.     { 
  11.         a = b;
  12.         cout<<"creat: "<<a<<endl;
  13.     }
  15. private:
  16.     //拷贝构造，只是声明
  17.     CExample(const CExample& C);
  19. public:
  20.     ~CExample()
  21.     {
  22.         cout<< "delete: "<<a<<endl;
  23.     }
  25.     void Show ()
  26.     {
  27.         cout<<a<<endl;
  28.     }
  29. };
  31. //全局函数
  32. void g_Fun(CExample C)
  33. {
  34.     cout<<"test"<<endl;
  35. }
  37. int main()
  38. {
  39.     CExample test(1);
  40.     //g_Fun(test); 按值传递将出错
  42.     return 0;
  43. }

五、一些注意问题

1. 拷贝构造函数里能调用private成员变量吗?
解答：这个问题是在网上见的，当时一下子有点晕。其时从名子我们就知道拷贝构造函数其时就是一个特殊的构造函数，操作的还是自己类的成员变量，所以不受private的限制。

2. 以下函数哪个是拷贝构造函数,为什么?

  1. X::X(const X&);    
  2. X::X(X);    
  3. X::X(X&, int a=1);    
  4. X::X(X&, int a=1, int b=2);

解答：对于一个类X, 如果一个构造函数的第一个参数是下列之一:
a) X&
b) const X&
c) volatile X&
d) const volatile X&
且没有其他参数或其他参数都有默认值,那么这个函数是拷贝构造函数.

  1. X::X(const X&);  //是拷贝构造函数    
  2. X::X(X&, int=1); //是拷贝构造函数   
  3. X::X(X&, int a=1, int b=2); //当然也是拷贝构造函数

3. 一个类中可以存在多于一个的拷贝构造函数吗?
解答：类中可以存在超过一个拷贝构造函数。

  1. class X { 
  2. public:       
  3.   X(const X&);      // const 的拷贝构造
  4.   X(X&);            // 非const的拷贝构造
  5. };

注意,如果一个类中只存在一个参数为 X& 的拷贝构造函数,那么就不能使用const X或volatile X的对象实行拷贝初始化.
因为typename已经指出要转换的类型，所以不需要参数。因为它是类的成员函数，所以是通过类对象来调用，从而告知要转换的值，因此不需要参数。