2. 程式人生 > >C++拷貝構造函數詳解

C++拷貝構造函數詳解

阿新 • • 發佈：2017-05-22
public 類對象 -m 都是 出錯 ons const 需要 new

轉自：http://blog.csdn.net/lwbeyond/article/details/6202256/

一. 什麽是拷貝構造函數

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

[c-sharp] view plain copy
  1. int a = 100;
  2. int b = a;


而類對象與普通對象不同，類對象內部結構一般較為復雜，存在各種成員變量。
下面看一個類對象拷貝的簡單例子。

[c-sharp] view plain copy
  1. #include <iostream>
  2. using namespace std;
  4. class CExample {
  5. private:
  6. 　int a;
  7. public:
  8. //構造函數
  9. 　CExample(int b)
  10. 　{ a = b;}
  12. //一般函數
  13. 　void Show ()
  14. 　{
  15. cout<<a<<endl;
  16. }
  17. };
  19. int main()
  20. {
  21. 　CExample A(100);
  22. 　CExample B = A; //註意這裏的對象初始化要調用拷貝構造函數，而非賦值
  23. 　 B.Show ();
  24. 　return 0;
  25. }

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

下面舉例說明拷貝構造函數的工作過程。

[c-sharp] view plain copy
  1. #include <iostream>
  2. using namespace std;
  4. class CExample {
  5. private:
  6. int a;
  7. public:
  8. //構造函數
  9. CExample(int b)
  10. { a = b;}
  12. //拷貝構造函數
  13. CExample(const CExample& C)
  14. {
  15. a = C.a;
  16. }
  18. //一般函數
  19. void Show ()
  20. {
  21. cout<<a<<endl;
  22. }
  23. };
  25. int main()
  26. {
  27. CExample A(100);
  28. CExample B = A; // CExample B(A); 也是一樣的
  29. B.Show ();
  30. return 0;
  31. }


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

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

在C++中，下面三種對象需要調用拷貝構造函數！
1. 對象以值傳遞的方式傳入函數參數

[c-sharp] view plain copy
  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. }
  21. //析構函數
  22. ~CExample()
  23. {
  24. cout<< "delete: "<<a<<endl;
  25. }
  27. void Show ()
  28. {
  29. cout<<a<<endl;
  30. }
  31. };
  33. //全局函數，傳入的是對象
  34. void g_Fun(CExample C)
  35. {
  36. cout<<"test"<<endl;
  37. }
  39. int main()
  40. {
  41. CExample test(1);
  42. //傳入對象
  43. g_Fun(test);
  45. return 0;
  46. }


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

2. 對象以值傳遞的方式從函數返回

[c-sharp] view plain copy
  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. 對象需要通過另外一個對象進行初始化；

[c-sharp] view plain copy
  1. CExample A(100);
  2. CExample B = A;
  3. // CExample B(A);

後兩句都會調用拷貝構造函數。

三. 淺拷貝和深拷貝

1. 默認拷貝構造函數

很多時候在我們都不知道拷貝構造函數的情況下，傳遞對象給函數參數或者函數返回對象都能很好的進行，這是因為編譯器會給我們自動產生一個拷貝構造函數，這就是“默認拷貝構造函數”，這個構造函數很簡單，僅僅使用“老對象”的數據成員的值對“新對象”的數據成員一一進行賦值，它一般具有以下形式：

[c-sharp] view plain copy
  1. Rect::Rect(const Rect& r)
  2. {
  3. width = r.width;
  4. height = r.height;
  5. }


當然，以上代碼不用我們編寫，編譯器會為我們自動生成。但是如果認為這樣就可以解決對象的復制問題，那就錯了，讓我們來考慮以下一段代碼：

[c-sharp] view plain copy
  1. class Rect
  2. {
  3. public:
  4. Rect() // 構造函數，計數器加1
  5. {
  6. count++;
  7. }
  8. ~Rect() // 析構函數，計數器減1
  9. {
  10. count--;
  11. }
  12. static int getCount() // 返回計數器的值
  13. {
  14. return count;
  15. }
  16. private:
  17. int width;
  18. int height;
  19. static int count; // 一靜態成員做為計數器
  20. };
  22. int Rect::count = 0; // 初始化計數器
  24. int main()
  25. {
  26. Rect rect1;
  27. cout<<"The count of Rect: "<<Rect::getCount()<<endl;
  29. Rect rect2(rect1); // 使用rect1復制rect2，此時應該有兩個對象
  30. cout<<"The count of Rect: "<<Rect::getCount()<<endl;
  32. return 0;
  33. }

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

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

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

[c-sharp] view plain copy
  1. class Rect
  2. {
  3. public:
  4. Rect() // 構造函數，計數器加1
  5. {
  6. count++;
  7. }
  8. Rect(const Rect& r) // 拷貝構造函數
  9. {
  10. width = r.width;
  11. height = r.height;
  12. count++; // 計數器加1
  13. }
  14. ~Rect() // 析構函數，計數器減1
  15. {
  16. count--;
  17. }
  18. static int getCount() // 返回計數器的值
  19. {
  20. return count;
  21. }
  22. private:
  23. int width;
  24. int height;
  25. static int count; // 一靜態成員做為計數器
  26. };

2. 淺拷貝

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

[c-sharp] view plain copy
  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對象後，由於在構造函數中有一個動態分配的語句，因此執行後的內存情況大致如下：

技術分享

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

技術分享

當然，這不是我們所期望的結果，在銷毀對象時，兩個對象的析構函數將對同一個內存空間釋放兩次，這就是錯誤出現的原因。我們需要的不是兩個p有相同的值，而是兩個p指向的空間有相同的值，解決辦法就是使用“深拷貝”。


3. 深拷貝

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

[c-sharp] view plain copy
  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. };

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

技術分享

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


3. 防止默認拷貝發生

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

[c-sharp] view plain copy
  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. 以下函數哪個是拷貝構造函數,為什麽?

[c-sharp] view plain copy
  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&
且沒有其他參數或其他參數都有默認值,那麽這個函數是拷貝構造函數.

[c-sharp] view plain copy
  1. X::X(const X&); //是拷貝構造函數
  2. X::X(X&, int=1); //是拷貝構造函數
  3. X::X(X&, int a=1, int b=2); //當然也是拷貝構造函數

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

[c-sharp] view plain copy
  1. class X {
  2. public:
  3. X(const X&); // const 的拷貝構造
  4. X(X&); // 非const的拷貝構造
  5. };


註意,如果一個類中只存在一個參數為 X& 的拷貝構造函數,那麽就不能使用const X或volatile X的對象實行拷貝初始化.

[c-sharp] view plain copy
  1. class X {
  2. public:
  3. X();
  4. X(X&);
  5. };
  7. const X cx;
  8. X x = cx; // error


如果一個類中沒有定義拷貝構造函數,那麽編譯器會自動產生一個默認的拷貝構造函數。
這個默認的參數可能為 X::X(const X&)或 X::X(X&),由編譯器根據上下文決定選擇哪一個。

C++拷貝構造函數詳解

相關推薦

C++拷貝構造函數詳解

public 類對象 -m 都是 出錯 ons const 需要 new 轉自：http://blog.csdn.net/lwbeyond/article/details/6202256/ 一. 什麽是拷貝構造函數 首先對於普通類型的對象來說，它們之間的復制是很簡單的，例如

【轉】C++拷貝構造函數詳解

簡單的 之間 其他 創建 變量 tac 動態分配空間 data 產生 一. 什麽是拷貝構造函數 首先對於普通類型的對象來說，它們之間的復制是很簡單的，例如： int a = 100; int b = a; 而類對象與普通對象不同，類對象內部結構一般較為復雜，

C++ 拷貝構造函數

div 必須 初始 view sni 調用 flow 初始化 round 作者 ： 卿篤軍 1）定義：拷貝構造函數，是一種特殊的構造函數。它由編譯器調用來完畢一些基於同一類的其它對象的構建及初始化。其唯一的形參必須是引用，但並不限制為const，一般普遍的

構造函數詳解

code ember pla 決定 mem 技術 har 實例化 sta 首先構造函數是為了給初始化對象賦初值 構造函數大類分為無參構造函數和有參構造函數，其次是靜態和非靜態構造函數 1 public class Test 2 { 3 i

關於windows下的c++的rand函數詳解

c++ rand rand不是真正的隨機函數，是偽隨機函數srand設置隨機函數種子srand設置一個參數後，每調用一次rand產生一個隨機數srand(1000001)rand – 21589rand – 29335rand – 14469 srand參數相同，多次調用rand依次返回的

C++拷貝構造函數(深拷貝，淺拷貝)

類型 拷貝構造 amp ica let 其它 hello 動態開辟 深拷貝和淺拷貝 對於普通類型的對象來說，它們之間的復制是很簡單的，例如：int a=88;int b=a; 而類對象與普通對象不同，類對象內部結構一般較為復雜，存在各種成員變量。下面看一個類對象拷

C++拷貝構造函數(深拷貝&淺拷貝)

border 技術分享 存在 ali ret 自定義 names src turn 對於普通類型的對象來說，它們之間的復制是很簡單的，例如： int a=88; int b=a; 而類對象與普通對象不同，類對象內部結構一般較為復雜，存在各種成員變量。下面看一個類對象拷貝的

c++拷貝構造函數(深拷貝、淺拷貝)——轉

完全復制 pla isp std c++ 必須 spa 例如 成員 拷貝構造函數： 拷貝構造函數是一種特殊的構造函數，函數的名稱必須和類名稱一致，它的唯一的一個參數是本類的一個引用變量，該參數是const類型，不可變的。例如：類A的拷貝構造函數的形式為A(A& x)

C++拷貝構造函數

private 自動 space 初始 public 限制 str2 階段 指向 目錄 一、對象的拷貝 二、以拷貝方式來初始化對象的例子 三、拷貝構造函數的定義及使用 四、

c++拷貝函數詳解(轉)

light clu 默認 fun 編譯 存在 自動生成 pri 指針成員 一. 什麽是拷貝構造函數 首先對於普通類型的對象來說，它們之間的復制是很簡單的，例如 int a = 100; int b = a; 而類對象與普通對象不同，類對象內部結構一般

C語言itoa()函數和atoi()函數詳解(整數轉字符C實現)

獲取 c++語言 end atof 定位 ray iostream 寫入 blog C語言提供了幾個標準庫函數，可以將任意類型(整型、長整型、浮點型等)的數字轉換為字符串。 1.int/float to string/array: C語言提供了幾個標準庫函數，可以將任意類型

C++知識點：拷貝構造函數例子

inside 現在 pan 創建 需要 string esp 傳遞對象 知識 //拷貝構造函數： //函數參數傳遞時調用一次拷貝構造函數，給對象賦值時調用一次拷貝構造函數，對象作為參數傳遞後會被及時銷毀。 #include <fstream> #include

c++類的拷貝、賦值與銷毀（拷貝構造函數、拷貝賦值運算符析構函數）

錯誤 保存 編譯 oid 生成 標準庫 int 為什麽 explicit 拷貝構造函數 如果一個構造函數的第一個參數是自身類類型的引用，且任何額外參數都有默認值，則此構造函數是拷貝構造函數。 拷貝構造函數第一個參數必須是一個引用類型。此參數幾乎總是一個con

C#函數式編程中的標準高階函數詳解

生活 back convert 大致 查看 pre 具體實現 plugins 轉載 何為高階函數 大家可能對這個名詞並不熟悉，但是這個名詞所表達的事物卻是我們經常使用到的。只要我們的函數的參數能夠接收函數，或者函數能夠返回函數，當然動態生成的也包括在內。那麽我們就將這

C++中的構造函數，拷貝構造函數，賦值函數

cpp 區域 操作 兩個 16px size 取值 基於 lan C++中一般創建對象，拷貝或賦值的方式有構造函數，拷貝構造函數，賦值函數這三種方法。下面就詳細比較下三者之間的區別以及它們的具體實現 1.構造函數 構造函數是一種特殊的類成員函數，是當創建一個類的對象時，它被

C++之拷貝構造函數

來看 原理 pac 又是 esp true UC 自身 AI 前段時間一直有個問題困擾著我————什麽是構造函數？？什麽又是拷貝構造函數？？ 由於小博平時工作中不經常用到拷貝構造函數之類的，而且自身又屬於那種碰到問題才會去尋求答案的類型，所以。。。（廢話有點多） ----

【校招面試 之 C++】第4題 拷貝構造函數被調用的3個時機

舉例 inf 操作符 -c 接收 clu 分享圖片 his 校招 1、被調用的3個時機： （1）直接初始化或拷貝初始化； （2）將一個對象作為一個實參傳遞，形參采用非指針或非引用的對象進行接收時； （3）函數的返回值是一個非指針或者非對象被接收時。 2、舉例說明： #

C++中的字符串輸入輸出函數詳解

c++ 這樣的 個數字 scan 保存 使用 收回 一次 用法 常見的輸入問題： 1、直接用cin輸入（當然可以使用cout直接輸出）： 　　1）string s; 　　　　cin >> s; //只接收回車鍵和空格前面所輸入的字符！！！！！

c/c++ socket函數詳解

astar 應該 type 表示 無法獲得 字節數 鏈接 .lib 隨機 c/c++ socket函數詳解 註意：　 使用socketAPI前，要先將相關鏈接庫（Ws2_32.lib）加入鏈接，並使用WSAStartUp函數初始化。每個socket函數都可能失敗（返回-

htonl()函數詳解

理解 問題 自定義 大端 編譯器 正常 lin 代碼 ret 在《Linux網絡編程》這本書中提到htonl()函數的原型。實現代碼如下： long htonl(long value) { 　　return ((value <<24 )|((value<&