一. 拷貝構造函數

 1 #include<iostream>
 2 using namespace std;
 3 class CExample
 4 {
 5 private:
 6     int a;
 7 public:
 8     //構造函數
 9     CExample(int b)
10     {
11         a=b;
12         printf("constructor is called
");
13     }
14     //拷貝構造函數
15     CExample(const CExample & c)
16     {
17         a=c.a;
18         printf("copy constructor is called
");
19     }
20     //析構函數
21     ~CExample()
22     {
23         cout<<"destructor is called
";
24     }
25     void Show()
26     {
27         cout<<a<<endl;
28     }
29 };
30 int main()
31 {
32     CExample A(100);
33     CExample B=A;
34     B.Show(); 
35     return 0;
36 }

View Code

就類對象而言，相同類型的類對象是通過拷貝構造函數來完成整個復制過程的。

運行程序，屏幕輸出100。從以上代碼的運行結果可以看出，系統為對象 B 分配了內存并完成了與對象 A 的復制過程。

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

二、拷貝構造函數的調用時機

1 當函數的參數為類的對象時

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

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;
}

View Code

這段代碼對前面的類，加入了一個靜態成員，目的是進行計數。在主函數中，首先創建對象rect1，輸出此時的對象個數，然后使用rect1復制出對象rect2，再輸出此時的對象個數，按照理解，此時應該有兩個對象存在，但實際程序運行時，輸出的都是1，反應出只有1個對象。此外，在銷毀對象時，由于會調用銷毀兩個對象，類的析構函數會調用兩次，此時的計數器將變為負數。說白了，就是拷貝構造函數沒有處理靜態數據成員。

出現這些問題最根本就在于在復制對象時，計數器沒有遞增，我們重新編寫拷貝構造函數，如下：

 1 #include<iostream>
 2 using namespace std;
 3 class Rect
 4 {
 5 public:
 6     Rect()
 7     {
 8         count++;
 9     }
10     Rect(const Rect& r)
11     {
12         width=r.width;
13         height=r.height;
14         count++;
15     }
16     ~Rect()
17     {
18         count--;
19     }
20     static int getCount()
21     {
22         return count;
23     }
24 private:
25     int width;
26     int height;
27     static int count;
28 };
29 int Rect::count=0;
30 int main()
31 {
32     Rect rect1;
33     cout<<"The count of Rect:"<<Rect::getCount()<<endl;
34     Rect rect2(rect1);
35     cout<<"The count of Rect:"<<Rect::getCount()<<endl;
36     return 0;
37 }

View Code

2.淺拷貝

所謂淺拷貝，指的是在對象復制時，只對對象中的數據成員進行簡單的賦值，默認拷貝構造函數執行的也是淺拷貝。大多情況下“淺拷貝”已經能很好地工作了，但是一旦對象存在了動態成員，那么淺拷貝就會出問題了，讓我們考慮如下一段代碼：

 1 #include<iostream>
 2 #include<assert.h>
 3 using namespace std;
 4 class Rect
 5 {
 6 public:
 7     Rect()
 8     {
 9      p=new int(100);
10     }
11    
12     ~Rect()
13     {
14      assert(p!=NULL);
15         delete p;
16     }
17 private:
18     int width;
19     int height;
20     int *p;
21 };
22 int main()
23 {
24     Rect rect1;
25     Rect rect2(rect1);
26     return 0;
27 }

View Code

在這段代碼運行結束之前，會出現一個運行錯誤。原因就在于在進行對象復制時，對于動態分配的內容沒有進行正確的操作。我們來分析一下：

在運行定義rect1對象后，由于在構造函數中有一個動態分配的語句，因此執行后的內存情況大致如下：

在使用rect1復制rect2時，由于執行的是淺拷貝，只是將成員的值進行賦值，這時rect1.p= rect2.p，也即這兩個指針指向了堆里的同一個空間，如下圖所示：

當然，這不是我們所期望的結果，在銷毀對象時，兩個對象的析構函數將對同一個內存空間釋放兩次，這就是錯誤出現的原因。我們需要的不是兩個p有相同的值，而是兩個p指向的空間有相同的值，解決辦法就是使用“深拷貝”。
3. 深拷貝
在“深拷貝”的情況下，對于對象中動態成員，就不能僅僅簡單地賦值了，而應該重新動態分配空間，如上面的例子就應該按照如下的方式進行處理：

 1 #include<iostream>
 2 #include<assert.h>
 3 using namespace std;
 4 class Rect
 5 {
 6 public:
 7     Rect()
 8     {
 9      p=new int(100);
10     }
11     
12     Rect(const Rect& r)
13     {
14      width=r.width;
15         height=r.height;
16      p=new int(100);
17         *p=*(r.p);
18     }
19      
20     ~Rect()
21     {
22      assert(p!=NULL);
23         delete p;
24     }
25 private:
26     int width;
27     int height;
28     int *p;
29 };
30 int main()
31 {
32     Rect rect1;
33     Rect rect2(rect1);
34     return 0;
35 }

View Code

此時，在完成對象的復制后，內存的一個大致情況如下：

此時rect1的p和rect2的p各自指向一段內存空間，但它們指向的空間具有相同的內容，這就是所謂的“深拷貝”。

3. 防止默認拷貝發生

通過對對象復制的分析，我們發現對象的復制大多在進行“值傳遞”時發生，這里有一個小技巧可以防止按值傳遞——聲明一個私有拷貝構造函數。甚至不必去定義這個拷貝構造函數，這樣因為拷貝構造函數是私有的，如果用戶試圖按值傳遞或函數返回該類對象，將得到一個編譯錯誤，從而可以避免按值傳遞或返回對象。

 1 //防止按值傳遞
 2 class CExample 
 3 { 
 4 private: 
 5     int a; 
 6   
 7 public: 
 8     //構造函數
 9     CExample(int b) 
10     { 
11         a = b; 
12         cout<<"creat: "<<a<<endl; 
13     } 
14   
15 private: 
16     //拷貝構造函數，只是聲明
17     CExample(const CExample& C); 
18   
19 public: 
20     ~CExample() 
21     { 
22         cout<< "delete: "<<a<<endl; 
23     } 
24   
25     void Show () 
26     { 
27         cout<<a<<endl; 
28     } 
29 }; 
30   
31 //???? 
32 void g_Fun(CExample C) 
33 { 
34     cout<<"test"<<endl; 
35 } 
36   
37 int main() 
38 { 
39     CExample test(1); 
40     //g_Fun(test);   //按值傳遞將出錯
41       
42     return 0; 
43 }

View Code

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

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

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

四、拷貝構造函數的幾個細節
1.為什么拷貝構造函數必須是引用傳遞，不能是值傳遞？
簡單的回答是為了防止遞歸引用。
具體一些可以這么講：
當一個對象需要以值方式傳遞時，編譯器會生成代碼調用它的拷貝構造函數以生成一個復本。如果類A的拷貝構造函數是以值方式傳遞一個類A對象作為參數的話，當需要調用類A的拷貝構造函數時，需要以值方式傳進一個A的對象作為實參；而以值方式傳遞需要調用類A的拷貝構造函數；結果就是調用類A的拷貝構造函數導致又一次調用類A的拷貝構造函數，這就是一個無限遞歸。

2. 拷貝構造函數的作用。
作用就是用來復制對象的，在使用這個對象的實例來初始化這個對象的一個新的實例。

3.參數傳遞過程到底發生了什么？
將地址傳遞和值傳遞統一起來，歸根結底還是傳遞的是"值"(地址也是值，只不過通過它可以找到另一個值)！
i)值傳遞:
對于內置數據類型的傳遞時，直接賦值拷貝給形參(注意形參是函數內局部變量)；
對于類類型的傳遞時，需要首先調用該類的拷貝構造函數來初始化形參(局部對象)；如voidfoo(class_typeobj_local){},如果調用foo(obj);首先class_typeobj_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&),由編譯器根據上下文決定選擇哪一個。

五、C++構造函數以及析構函數的若干面試問題

Q1：構造函數能否重載，析構函數能否重載，為什么？
A1：構造函數可以，析構函數不可以。

Q2：析構函數為什么一般情況下要聲明為虛函數？
A2：虛函數是實現多態的基礎，當我們通過基類的指針是析構子類對象時候，如果不定義成虛函數，那只調用基類的析構函數，子類的析構函數將不會被調用。如 果定義為虛函數，則子類父類的析構函數都會被調用。
Q3：什么情況下必須定義拷貝構造函數？
A3：當類的對象用于函數值傳遞時（值參數，返回類對象），拷貝構造函數會被調用。如果對象復制并非簡單的值拷貝，那就必須定義拷貝構造函數。例如大的堆 棧數據拷貝。如果定義了拷貝構造函數，那也必須重載賦值操作符。

總結

以上是生活随笔為你收集整理的拷贝构造函数的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。