一. 什么是拷貝構(gòu)造函數(shù)

首先對于普通類型的對象來說，它們之間的復(fù)制是很簡單的，例如：

int a = 100;  int b = a;   而類對象與普通對象不同，類對象內(nèi)部結(jié)構(gòu)一般較為復(fù)雜，存在各種成員變量。下面看一個類對象拷貝的簡單例子。
#include <iostream>  using namespace std;    class CExample {  PRivate:      　int a;  public:        //構(gòu)造函數(shù)      　CExample(int b)      　{ a = b;}          //一般函數(shù)      　void Show ()      　{          cout<<a<<endl;        }  };    int main()  {      　CExample A(100);      　CExample B = A; //注意這里的對象初始化要調(diào)用拷貝構(gòu)造函數(shù)，而非賦值      　 B.Show ();      　return 0;  }  運行程序，屏幕輸出100。從以上代碼的運行結(jié)果可以看出，系統(tǒng)為對象 B 分配了內(nèi)存并完成了與對象 A 的復(fù)制過程。就類對象而言，相同類型的類對象是通過拷貝構(gòu)造函數(shù)來完成整個復(fù)制過程的。下面舉例說明拷貝構(gòu)造函數(shù)的工作過程。
#include <iostream>  using namespace std;    class CExample {  private:      int a;  public:      //構(gòu)造函數(shù)      CExample(int b)      { a = b;}            //拷貝構(gòu)造函數(shù)      CExample(const CExample& C)      {          a = C.a;      }        //一般函數(shù)      void Show ()      {          cout<<a<<endl;      }  };    int main()  {      CExample A(100);      CExample B = A; // CExample B(A); 也是一樣的       B.Show ();      return 0;  }   CExample(const CExample& C)　就是我們自定義的拷貝構(gòu)造函數(shù)。可見，拷貝構(gòu)造函數(shù)是一種特殊的構(gòu)造函數(shù)，函數(shù)的名稱必須和類名稱一致，它必須的一個參數(shù)是本類型的一個引用變量。
二. 拷貝構(gòu)造函數(shù)的調(diào)用時機
在C++中，下面三種對象需要調(diào)用拷貝構(gòu)造函數(shù)！1. 對象以值傳遞的方式傳入函數(shù)參數(shù)
class CExample   {  private:   int a;    public:   //構(gòu)造函數(shù)   CExample(int b)   {     a = b;    cout<<"creat: "<<a<<endl;   }     //拷貝構(gòu)造   CExample(const CExample& C)   {    a = C.a;    cout<<"copy"<<endl;   }      //析構(gòu)函數(shù)   ~CExample()   {    cout<< "delete: "<<a<<endl;   }         void Show ()   {           cout<<a<<endl;       }  };    //全局函數(shù)，傳入的是對象  void g_Fun(CExample C)  {   cout<<"test"<<endl;  }    int main()  {   CExample test(1);   //傳入對象   g_Fun(test);     return 0;  }  調(diào)用g_Fun()時，會產(chǎn)生以下幾個重要步驟：(1).test對象傳入形參時，會先會產(chǎn)生一個臨時變量，就叫 C 吧。(2).然后調(diào)用拷貝構(gòu)造函數(shù)把test的值給C。 整個這兩個步驟有點像：CExample C(test);(3).等g_Fun()執(zhí)行完后, 析構(gòu)掉 C 對象。2. 對象以值傳遞的方式從函數(shù)返回
class CExample   {  private:   int a;    public:   //構(gòu)造函數(shù)   CExample(int b)   {     a = b;   }     //拷貝構(gòu)造   CExample(const CExample& C)   {    a = C.a;    cout<<"copy"<<endl;   }         void Show ()       {           cout<<a<<endl;       }  };    //全局函數(shù)  CExample g_Fun()  {   CExample temp(0);   return temp;  }    int main()  {   g_Fun();   return 0;  }  當(dāng)g_Fun()函數(shù)執(zhí)行到return時，會產(chǎn)生以下幾個重要步驟：(1). 先會產(chǎn)生一個臨時變量，就叫XXXX吧。(2). 然后調(diào)用拷貝構(gòu)造函數(shù)把temp的值給XXXX。整個這兩個步驟有點像：CExample XXXX(temp);(3). 在函數(shù)執(zhí)行到最后先析構(gòu)temp局部變量。(4). 等g_Fun()執(zhí)行完后再析構(gòu)掉XXXX對象。
3. 對象需要通過另外一個對象進(jìn)行初始化；
CExample A(100);  CExample B = A;   // CExample B(A);   后兩句都會調(diào)用拷貝構(gòu)造函數(shù)。
三. 淺拷貝和深拷貝1. 默認(rèn)拷貝構(gòu)造函數(shù)很多時候在我們都不知道拷貝構(gòu)造函數(shù)的情況下，傳遞對象給函數(shù)參數(shù)或者函數(shù)返回對象都能很好的進(jìn)行，這是因為編譯器會給我們自動產(chǎn)生一個拷貝構(gòu)造函數(shù)，這就是“默認(rèn)拷貝構(gòu)造函數(shù)”，這個構(gòu)造函數(shù)很簡單，僅僅使用“老對象”的數(shù)據(jù)成員的值對“新對象”的數(shù)據(jù)成員一一進(jìn)行賦值，它一般具有以下形式：
Rect::Rect(const Rect& r)  {      width = r.width;      height = r.height;  }  當(dāng)然，以上代碼不用我們編寫，編譯器會為我們自動生成。但是如果認(rèn)為這樣就可以解決對象的復(fù)制問題，那就錯了，讓我們來考慮以下一段代碼：
class Rect  {  public:      Rect()      // 構(gòu)造函數(shù)，計數(shù)器加1      {          count++;      }      ~Rect()     // 析構(gòu)函數(shù)，計數(shù)器減1      {          count--;      }      static int getCount()       // 返回計數(shù)器的值      {          return count;      }  private:      int width;      int height;      static int count;       // 一靜態(tài)成員做為計數(shù)器  };    int Rect::count = 0;        // 初始化計數(shù)器    int main()  {      Rect rect1;      cout<<"The count of Rect: "<<Rect::getCount()<<endl;        Rect rect2(rect1);   // 使用rect1復(fù)制rect2，此時應(yīng)該有兩個對象       cout<<"The count of Rect: "<<Rect::getCount()<<endl;        return 0;  }  這段代碼對前面的類，加入了一個靜態(tài)成員，目的是進(jìn)行計數(shù)。在主函數(shù)中，首先創(chuàng)建對象rect1，輸出此時的對象個數(shù)，然后使用rect1復(fù)制出對象rect2，再輸出此時的對象個數(shù)，按照理解，此時應(yīng)該有兩個對象存在，但實際程序運行時，輸出的都是1，反應(yīng)出只有1個對象。此外，在銷毀對象時，由于會調(diào)用銷毀兩個對象，類的析構(gòu)函數(shù)會調(diào)用兩次，此時的計數(shù)器將變?yōu)樨?fù)數(shù)。說白了，就是拷貝構(gòu)造函數(shù)沒有處理靜態(tài)數(shù)據(jù)成員。出現(xiàn)這些問題最根本就在于在復(fù)制對象時，計數(shù)器沒有遞增，我們重新編寫拷貝構(gòu)造函數(shù)，如下：
class Rect  {  public:      Rect()      // 構(gòu)造函數(shù)，計數(shù)器加1      {          count++;      }      Rect(const Rect& r)   // 拷貝構(gòu)造函數(shù)      {          width = r.width;          height = r.height;          count++;          // 計數(shù)器加1      }      ~Rect()     // 析構(gòu)函數(shù)，計數(shù)器減1      {          count--;      }      static int getCount()   // 返回計數(shù)器的值      {          return count;      }  private:      int width;      int height;      static int count;       // 一靜態(tài)成員做為計數(shù)器  };  2. 淺拷貝所謂淺拷貝，指的是在對象復(fù)制時，只對對象中的數(shù)據(jù)成員進(jìn)行簡單的賦值，默認(rèn)拷貝構(gòu)造函數(shù)執(zhí)行的也是淺拷貝。大多情況下“淺拷貝”已經(jīng)能很好地工作了，但是一旦對象存在了動態(tài)成員，那么淺拷貝就會出問題了，讓我們考慮如下一段代碼：
class Rect  {  public:      Rect()      // 構(gòu)造函數(shù)，p指向堆中分配的一空間      {          p = new int(100);      }      ~Rect()     // 析構(gòu)函數(shù)，釋放動態(tài)分配的空間      {          if(p != NULL)          {              delete p;          }      }  private:      int width;      int height;      int *p;     // 一指針成員  };    int main()  {      Rect rect1;      Rect rect2(rect1);   // 復(fù)制對象      return 0;  }  在這段代碼運行結(jié)束之前，會出現(xiàn)一個運行錯誤。原因就在于在進(jìn)行對象復(fù)制時，對于動態(tài)分配的內(nèi)容沒有進(jìn)行正確的操作。我們來分析一下：在運行定義rect1對象后，由于在構(gòu)造函數(shù)中有一個動態(tài)分配的語句，因此執(zhí)行后的內(nèi)存情況大致如下：在使用rect1復(fù)制rect2時，由于執(zhí)行的是淺拷貝，只是將成員的值進(jìn)行賦值，這時 rect1.p = rect2.p，也即這兩個指針指向了堆里的同一個空間，如下圖所示：
當(dāng)然，這不是我們所期望的結(jié)果，在銷毀對象時，兩個對象的析構(gòu)函數(shù)將對同一個內(nèi)存空間釋放兩次，這就是錯誤出現(xiàn)的原因。我們需要的不是兩個p有相同的值，而是兩個p指向的空間有相同的值，解決辦法就是使用“深拷貝”。3. 深拷貝在“深拷貝”的情況下，對于對象中動態(tài)成員，就不能僅僅簡單地賦值了，而應(yīng)該重新動態(tài)分配空間，如上面的例子就應(yīng)該按照如下的方式進(jìn)行處理：
class Rect  {  public:      Rect()      // 構(gòu)造函數(shù)，p指向堆中分配的一空間      {          p = new int(100);      }      Rect(const Rect& r)      {          width = r.width;          height = r.height;          p = new int;    // 為新對象重新動態(tài)分配空間          *p = *(r.p);      }      ~Rect()     // 析構(gòu)函數(shù)，釋放動態(tài)分配的空間      {          if(p != NULL)          {              delete p;          }      }  private:      int width;      int height;      int *p;     // 一指針成員  };  此時，在完成對象的復(fù)制后，內(nèi)存的一個大致情況如下：此時rect1的p和rect2的p各自指向一段內(nèi)存空間，但它們指向的空間具有相同的內(nèi)容，這就是所謂的“深拷貝”。3. 防止默認(rèn)拷貝發(fā)生通過對對象復(fù)制的分析，我們發(fā)現(xiàn)對象的復(fù)制大多在進(jìn)行“值傳遞”時發(fā)生，這里有一個小技巧可以防止按值傳遞——聲明一個私有拷貝構(gòu)造函數(shù)。甚至不必去定義這個拷貝構(gòu)造函數(shù)，這樣因為拷貝構(gòu)造函數(shù)是私有的，如果用戶試圖按值傳遞或函數(shù)返回該類對象，將得到一個編譯錯誤，從而可以避免按值傳遞或返回對象。
// 防止按值傳遞  class CExample   {  private:      int a;    public:      //構(gòu)造函數(shù)      CExample(int b)      {           a = b;          cout<<"creat: "<<a<<endl;      }    private:      //拷貝構(gòu)造，只是聲明      CExample(const CExample& C);    public:      ~CExample()      {          cout<< "delete: "<<a<<endl;      }        void Show ()      {          cout<<a<<endl;      }  };    //全局函數(shù)  void g_Fun(CExample C)  {      cout<<"test"<<endl;  }    int main()  {      CExample test(1);      //g_Fun(test); 按值傳遞將出錯            return 0;  }   四. 拷貝構(gòu)造函數(shù)的幾個細(xì)節(jié)1. 拷貝構(gòu)造函數(shù)里能調(diào)用private成員變量嗎?解答：這個問題是在網(wǎng)上見的，當(dāng)時一下子有點暈。其時從名子我們就知道拷貝構(gòu)造函數(shù)其時就是一個特殊的構(gòu)造函數(shù)，操作的還是自己類的成員變量，所以不受private的限制。2. 以下函數(shù)哪個是拷貝構(gòu)造函數(shù),為什么?
X::X(const X&);      X::X(X);      X::X(X&, int a=1);      X::X(X&, int a=1, int b=2); 解答：對于一個類X, 如果一個構(gòu)造函數(shù)的第一個參數(shù)是下列之一:a) X&b) const X&c) volatile X&d) const volatile X&且沒有其他參數(shù)或其他參數(shù)都有默認(rèn)值,那么這個函數(shù)是拷貝構(gòu)造函數(shù).
X::X(const X&);  //是拷貝構(gòu)造函數(shù)      X::X(X&, int=1); //是拷貝構(gòu)造函數(shù)     X::X(X&, int a=1, int b=2); //當(dāng)然也是拷貝構(gòu)造函數(shù)  3. 一個類中可以存在多于一個的拷貝構(gòu)造函數(shù)嗎?解答：類中可以存在超過一個拷貝構(gòu)造函數(shù)。
class X {   public:           X(const X&);      // const 的拷貝構(gòu)造    X(X&);            // 非const的拷貝構(gòu)造  };  注意,如果一個類中只存在一個參數(shù)為 X& 的拷貝構(gòu)造函數(shù),那么就不能使用const X或volatile X的對象實行拷貝初始化.
class X {      public:    X();        X(X&);  };        const X cx;      X x = cx;    // error  如果一個類中沒有定義拷貝構(gòu)造函數(shù),那么編譯器會自動產(chǎn)生一個默認(rèn)的拷貝構(gòu)造函數(shù)。這個默認(rèn)的參數(shù)可能為 X::X(const X&)或 X::X(X&),由編譯器根據(jù)上下文決定選擇哪一個。本文裝載自http://blog.csdn.net/lwbeyond/article/details/6202256/