c++拷貝構造函數詳解

1、什麼是拷貝構造函數

      首先對於普通類型的對象來講，它們之間的複製是很簡單的，例如：

int a=100; int b=a;

 

  而類對象與普通對象不一樣，類對象內部結構通常較爲複雜，存在各類成員變量。
  下面看一個類對象拷貝的簡單例子。
   

#include<iostream>
using namespace std; class CExample { private: int a; public: //構造函數 CExample(int b) { a=b; printf("constructor is called\n"); } //拷貝構造函數 CExample(const CExample & c) { a=c.a; printf("copy constructor is called\n"); } //析構函數 ~CExample() { cout<<"destructor is called\n"; } void Show() { cout<<a<<endl; } }; int main() { CExample A(100); CExample B=A; B.Show(); return 0; }

   運行程序，屏幕輸出100。從以上代碼的運行結果能夠看出，系統爲對象 B 分配了內存並完成了與對象 A 的複製過程。就類對象而言，相同類型的類對象是經過拷貝構造函數來完成整個複製過程的。
  

 CExample(const CExample& C)　就是咱們自定義的拷貝構造函數。可見，拷貝構造函數是一種 特殊的 構造函數，函數的名稱必須和類名稱一致，它必須的一個參數是本類型的一個 引用變量。

2、拷貝構造函數的調用時機
     1. 當函數的參數爲類的對象時
  

  
#include<iostream>
using namespace std; class CExample { private: int a; public: CExample(int b) { a=b; printf("constructor is called\n"); } CExample(const CExample & c) { a=c.a; printf("copy constructor is called\n"); } ~CExample() { cout<<"destructor is called\n"; } void Show() { cout<<a<<endl; } }; void g_fun(CExample c) { cout<<"g_func"<<endl; } int main() { CExample A(100); CExample B=A; B.Show(); g_fun(A); return 0; }

 

 調用g_fun()時，會產生如下幾個重要步驟：
(1).A對象傳入形參時，會先會產生一個臨時變量，就叫 C 吧。
(2).而後調用拷貝構造函數把A的值給C。 整個這兩個步驟有點像：CExample C(A);
(3).等g_fun()執行完後, 析構掉 C 對象。  

    

2. 函數的返回值是類的對象
  

#include<iostream>
using namespace std; class CExample { private: int a; public: //構造函數 CExample(int b) { a=b; printf("constructor is called\n"); } //拷貝構造函數 CExample(const CExample & c) { a=c.a; printf("copy constructor is called\n"); } //析構函數 ~CExample() { cout<<"destructor is called\n"; } void Show() { cout<<a<<endl; } }; CExample g_fun() { CExample temp(0); return temp; } int main() { g_fun(); return 0; }

 

   當g_Fun()函數執行到return時，會產生如下幾個重要步驟：
(1). 先會產生一個臨時變量，就叫XXXX吧。
(2). 而後調用拷貝構造函數把temp的值給XXXX。整個這兩個步驟有點像：CExample XXXX(temp);
(3). 在函數執行到最後先析構temp局部變量。
(4). 等g_fun()執行完後再析構掉XXXX對象。  
  
 
3. 對象須要經過另一個對象進行初始化

CExample A(100); CExample B=A;

3、淺拷貝與深拷貝
     1. 默認拷貝構造函數
   不少時候在咱們都不知道拷貝構造函數的狀況下，傳遞對象給函數參數或者函數返回對象都能很好的進行，這是由於編譯器會給咱們自動產生一個拷貝構造函數，這就是「默認拷貝構造函數」，這個構造函數很簡單，僅僅使用「老對象」的數據成員的值對「新對象」的數據成員一一進行賦值，它通常具備如下形式：

Rect::Rect(const Rect& r) { width=r.width; height=r.height; }

固然，以上代碼不用咱們編寫，編譯器會爲咱們自動生成。可是若是認爲這樣就能夠解決對象的複製問題，那就錯了，讓咱們來考慮如下一段代碼：
 

 
#include<iostream>
using namespace std; class Rect { public: Rect() { count++; } ~Rect() { count--; } static int getCount() { return count; } private: int width; int height; static int count; }; int Rect::count=0; int main() { Rect rect1; cout<<"The count of Rect:"<<Rect::getCount()<<endl; Rect rect2(rect1); cout<<"The count of Rect:"<<Rect::getCount()<<endl; return 0; } 

這段代碼對前面的類，加入了一個靜態成員，目的是進行計數。在主函數中，首先建立對象rect1，輸出此時的對象個數，而後使用rect1複製出對象rect2，再輸出此時的對象個數，按照理解，此時應該有兩個對象存在，但實際程序運行時，輸出的都是1，反應出只有1個對象。此外，在銷燬對象時，因爲會調用銷燬兩個對象，類的析構函數會調用兩次，此時的計數器將變爲負數。

說白了，就是拷貝構造函數沒有處理靜態數據成員。

出現這些問題最根本就在於在複製對象時，計數器沒有遞增，咱們從新編寫拷貝構造函數，以下：

#include<iostream>
using namespace std; class Rect { public: Rect() { count++; } Rect(const Rect& r) { width=r.width; height=r.height; count++; } ~Rect() { count--; } static int getCount() { return count; } private: int width; int height; static int count; }; int Rect::count=0; int main() { Rect rect1; cout<<"The count of Rect:"<<Rect::getCount()<<endl; Rect rect2(rect1); cout<<"The count of Rect:"<<Rect::getCount()<<endl; return 0; }

  2. 淺拷貝

    所謂淺拷貝，指的是在對象複製時，只對對象中的數據成員進行簡單的賦值，默認拷貝構造函數執行的也是淺拷貝。大多狀況下「淺拷貝」已經能很好地工做了，可是一旦對象存在了動態成員，那麼淺拷貝就會出問題了，讓咱們考慮以下一段代碼：

 

#include<iostream>
#include<assert.h>
using namespace std; class Rect { public: Rect() { p=new int(100); } ~Rect() { assert(p!=NULL); delete p; } private: int width; int height; int *p; }; int main() { Rect rect1; Rect rect2(rect1); return 0; }

 

 在這段代碼運行結束以前，會出現一個運行錯誤。緣由就在於在進行對象複製時，對於動態分配的內容沒有進行正確的操做。咱們來分析一下：

    在運行定義rect1對象後，因爲在構造函數中有一個動態分配的語句，所以執行後的內存狀況大體以下：

     
  在使用rect1複製rect2時，因爲執行的是淺拷貝，只是將成員的值進行賦值，這時 rect1.p = rect2.p，也即這兩個指針指向了堆裏的同一個空間，以下圖所示：
    

 固然，這不是咱們所指望的結果，在銷燬對象時，兩個對象的析構函數將對同一個內存空間釋放兩次，這就是錯誤出現的緣由。咱們須要的不是兩個p有相同的值，而是兩個p指向的空間有相同的值，解決辦法就是使用「深拷貝」。
 
   3. 深拷貝

  在「深拷貝」的狀況下，對於對象中動態成員，就不能僅僅簡單地賦值了，而應該從新動態分配空間，如上面的例子就應該按照以下的方式進行處理：

 

#include<iostream>
#include<assert.h>
using namespace std; class Rect { public: Rect() { p=new int(100); } Rect(const Rect& r) { width=r.width; height=r.height; p=new int(100); *p=*(r.p); } ~Rect() { assert(p!=NULL); delete p; } private: int width; int height; int *p; }; int main() { Rect rect1; Rect rect2(rect1); return 0; }

 

  此時，在完成對象的複製後，內存的一個大體狀況以下：
   
此時rect1的p和rect2的p各自指向一段內存空間，但它們指向的空間具備相同的內容，這就是所謂的「深拷貝」。

3. 防止默認拷貝發生

    經過對對象複製的分析，咱們發現對象的複製大多在進行「值傳遞」時發生，這裏有一個小技巧能夠防止按值傳遞——聲明一個私有拷貝構造函數。甚至沒必要去定義這個拷貝構造函數，這樣由於拷貝構造函數是私有的，若是用戶試圖按值傳遞或函數返回該類對象，將獲得一個編譯錯誤，從而能夠避免按值傳遞或返回對象。

 
//防止按值傳遞 class CExample { private: int a; public: //構造函數 CExample(int b) { a = b; cout<<"creat: "<<a<<endl; } private: //拷貝構造函數，只是聲明 CExample(const CExample& C); public: ~CExample() { cout<< "delete: "<<a<<endl; } void Show () { cout<<a<<endl; } }; //???? void g_Fun(CExample C) { cout<<"test"<<endl; } int main() { CExample test(1); //g_Fun(test); //按值傳遞將出錯 return 0; }

小結：
    拷貝有兩種：深拷貝，淺拷貝。

      當出現類的等號賦值時，會調用拷貝函數，在未定義顯示拷貝構造函數的狀況下，系統會調用默認的拷貝函數——即淺拷貝，它可以完成成員的一一複製。當數據成員中沒有指針時，淺拷貝是可行的。但當數據成員中有指針時，若是採用簡單的淺拷貝，則兩類中的兩個指針將指向同一個地址，當對象快結束時，會調用兩次析構函數，而致使指針懸掛現象。因此，這時，必須採用深拷貝。

     深拷貝與淺拷貝的區別就在於深拷貝會在堆內存中另外申請空間來儲存數據，從而也就解決了指針懸掛的問題。簡而言之，當數據成員中有指針時，必需要用深拷貝。

4、拷貝構造函數的幾個細節
   1.爲何拷貝構造函數必須是引用傳遞，不能是值傳遞？
     簡單的回答是爲了防止遞歸引用。
          具體一些能夠這麼講：
              當 一個對象須要以值方式傳遞時，編譯器會生成代碼調用它的拷貝構造函數以生成一個複本。若是類A的拷貝構造函數是以值方式傳遞一個類A對象做爲參數的話，當 須要調用類A的拷貝構造函數時，須要以值方式傳進一個A的對象做爲實參； 而以值方式傳遞須要調用類A的拷貝構造函數；結果就是調用類A的拷貝構造函數導 致又一次調用類A的拷貝構造函數，這就是一個無限遞歸。
    
   2. 拷貝構造函數的做用。     
           做用就是用來複制對象的，在使用這個對象的實例來初始化這個對象的一個新的實例。

     3.參數傳遞過程到底發生了什麼？
      將地址傳遞和值傳遞統一塊兒來，歸根結底仍是傳遞的是"值"(地址也是值，只不過經過它能夠找到另外一個值)！
      i)值傳遞:
         對於內置數據類型的傳遞時，直接賦值拷貝給形參(注意形參是函數內局部變量)；
         對於類類型的傳遞時，須要首先調用該類的拷貝構造函數來初始化形參(局部對象)；如void foo(class_type obj_local){}, 若是調用foo(obj);  首先class_type obj_local(obj) ,這樣就定義了局部變量obj_local供函數內部使用
     ii)引用傳遞:
        不管對內置類型仍是類類型，傳遞引用或指針最終都是傳遞的地址值！而地址老是指針類型(屬於簡單類型), 顯然參數傳遞時，按簡單類型的賦值拷貝，而不會有拷貝構造函數的調用(對於類類型).

   4. 在類中有指針數據成員時，拷貝構造函數的使用？
        若是不顯式聲明拷貝構造函數的時候，編譯器也會生成一個默認的拷貝構造函數，並且在通常的狀況下運行的也很好。可是在遇到類有指針數據成員時就出現問題 了：由於默認的拷貝構造函數是按成員拷貝構造，這致使了兩個不一樣的指針(如ptr1=ptr2)指向了相同的內存。當一個實例銷燬時，調用析構函數 free(ptr1)釋放了這段內存，那麼剩下的一個實例的指針ptr2就無效了，在被銷燬的時候free(ptr2)就會出現錯誤了, 這至關於重複釋放一塊內存兩次。這種狀況必須顯式聲明並實現本身的拷貝構造函數，來爲新的實例的指針分配新的內存。

問題1和2回答了爲何拷貝構造函數使用值傳遞會產生無限遞歸調用的問題；
問題3回答了回答了在類中有指針數據成員時，拷貝構造函數使用值傳遞等於白顯式定義了拷貝構造函數，由於默認的拷貝構造函數就是這麼幹的。
 

  5. 拷貝構造函數裏能調用private成員變量嗎?
解答：這個問題是在網上見的，當時一會兒有點暈。其時從名子咱們就知道拷貝構造函數其時就是一個特殊的構造函數，操做的仍是本身類的成員變量，因此不受private的限制。

 6. 如下函數哪一個是拷貝構造函數,爲何?

 
X::X(const X&); //拷貝構造函數 X::X(X); X::X(X&, int a=1); //拷貝構造函數 X::X(X&, int a=1, int b=2); //拷貝構造函數

   解答：對於一個類X, 若是一個構造函數的第一個參數是下列之一:
   a) X&
   b) const X&
   c) volatile X&
   d) const volatile X&
   且沒有其餘參數或其餘參數都有默認值,那麼這個函數是拷貝構造函數.

  7. 一個類中能夠存在多於一個的拷貝構造函數嗎?
   解答：類中能夠存在超過一個拷貝構造函數。

  
class X { public: X(const X&); // const 的拷貝構造 X(X&); // 非const的拷貝構造 };

 

  注意,若是一個類中只存在一個參數爲 X& 的拷貝構造函數,那麼就不能使用const X或volatile X的對象實行拷貝初始化.
  若是一個類中沒有定義拷貝構造函數,那麼編譯器會自動產生一個默認的拷貝構造函數。
  這個默認的參數可能爲 X::X(const X&)或 X::X(X&),由編譯器根據上下文決定選擇哪個。

     
5、C++構造函數以及析構函數的若干面試問題
 
 Q1：構造函數可否重載，析構函數可否重載，爲何？
 A1：構造函數能夠，析構函數不能夠。

 

  Q2：析構函數爲何通常狀況下要聲明爲虛函數？

  A2：虛函數是實現多態的基礎，當咱們經過基類的指針是析構子類對象時候，若是不定義成虛函數，那隻調用基類的析構函數，子類的析構函數將不會被調用。如       果定義爲虛函數，則子類父類的析構函數都會被調用。

  Q3：什麼狀況下必須定義拷貝構造函數？

  A3：當類的對象用於函數值傳遞時（值參數，返回類對象），拷貝構造函數會被調用。若是對象複製並不是簡單的值拷貝，那就必須定義拷貝構造函數。例如大的堆       棧數據拷貝。若是定義了拷貝構造函數，那也必須重載賦值操做符。

參考博客：
  http://blog.csdn.net/lwbeyond/article/details/6202256
http://jaden.blog.51cto.com/1549175/324480
http://blog.chinaunix.net/uid-28662931-id-3496322.html