構造函數 【轉】C++拷貝構造函數詳解
【轉】C++拷貝構造函數詳解html
1、什麼是拷貝構造函數
首先對於普通類型的對象來講，它們之間的複製是很簡單的，例如：ios
int a=100; int b=a;
而類對象與普通對象不一樣，類對象內部結構通常較爲複雜，存在各類成員變量。函數
下面看一個類對象拷貝的簡單例子。post
#include <iostream>
using namespace std;
class CExample {
private:
int a;
public:
//構造函數
CExample(int b)
{ a = b;}
//通常函數
void Show ()
{
cout<<a<<endl;
}
};
int main()
{
CExample A(100);
CExample B = A; //注意這裏的對象初始化要調用拷貝構造函數，而非賦值
B.Show ();
return 0;
}
運行程序，屏幕輸出100。從以上代碼的運行結果能夠看出，系統爲對象B分配了內存並完成了與對象A的複製過程。（實際是編譯器給咱們自動產生一個拷貝構造函數）。就類對象而言，相同類型的類對象是經過拷貝構造函數來完成整個複製過程的。url
下面舉例說明拷貝構造函數的工做過程。spa
#include <iostream>
using namespace std;
class CExample {
private:
int a;
public:
//構造函數
CExample(int a)
{
a = b;
}
//拷貝構造函數
CExample(const CExample& C)
{
a = C.a;
}
//通常函數
void show()
{
cout << a << endl;
}
};
int main()
{
CExample A(100);
CExample B = A;// CExample B(A); 也是同樣的
B.show();
return 0;
}
CExample(const CExample& C) 就是咱們自定義的拷貝構造函數。可見，拷貝構造函數是一種特殊的構造函數，函數的名稱必須和類名稱一致，它必須的一個參數是本類型的一個引用變量。.net
2、拷貝構造函數的調用時機指針
在C++中，下面三種對象須要調用拷貝構造函數！code
一、對象以值傳遞的方式傳入函數參數htm
class CExample
{
private:
int a;
public:
//構造函數
CExample(int b)
{
a = b;
cout<<"creat: "<<a<<endl;
}
//拷貝構造
CExample(const CExample& C)
{
a = C.a;
cout<<"copy"<<endl;
}
//析構函數
~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;
}
調用g_Fun()時，會產生如下幾個重要步驟：
（1）.test對象傳入形參時，會先產生一個臨時變量，就叫C吧。
（2）.而後調用拷貝構造函數把test的值給C。這兩個步驟有點像：CExample C(test);
（3）.等g_Fun()執行完後，析構掉C對象。
二、對象以值傳遞的方式從函數返回
class CExample
{
private:
int a;
public:
//構造函數
CExample(int b)
{
a = b;
}
//拷貝構造
CExample(const CExample& C)
{
a = C.a;
cout<<"copy"<<endl;
}
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對象。
三、對象須要經過另一個對象進行初始化
CExample A(100); CExample B = A; // CExample B(A);
後兩句都會調用拷貝構造函數。
3、淺拷貝和深拷貝
一、默認拷貝構造函數
不少時候在咱們都不知道拷貝構造函數的狀況下，傳遞對象給函數參數或者函數返回對象都能很好地進行，這是由於編譯器會給咱們自動產生一個拷貝構造函數，這就是「默認拷貝構造函數」，這個構造函數很簡單，僅僅使用「老對象」的數據成員的值對「新對象」的數據成員一一進行賦值，它通常具備如下形式：
Rect::Rect(const Rect& r)
{
width = r.width;
height = r.height;
}
固然，以上代碼不用咱們編寫，編譯器會爲咱們自動生成。可是若是認爲這樣就能夠解決對象的複製問題，那就錯了，讓咱們來考慮如下一段代碼：
class Rect
{
public:
Rect() // 構造函數，計數器加1
{
count++;
}
~Rect() // 析構函數，計數器減1
{
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); // 使用rect1複製rect2，此時應該有兩個對象
cout<<"The count of Rect: "<<Rect::getCount()<<endl;
return 0;
}
這段代碼對前面的類，加入了一個靜態成員，目的是進行計數。在主函數中，首先建立對象rect1，輸出此時的對象個數，而後使用rect1複製出對象rect2，再輸出此時的對象個數，按照理解，此時應該有兩個對象存在，但實際程序運行時，輸出的都是1，反映出只有1個對象。此外，在銷燬對象時，因爲會調用銷燬兩個對象，類的析構函數會調用兩次，此時的計數器將變爲負數。
說白了，就是拷貝構造函數沒有處理靜態數據成員。
出現這些問題最根本的在於複製對象時，計數器沒有遞增，咱們從新編寫拷貝構造函數，以下：
class Rect
{
public:
Rect() // 構造函數，計數器加1
{
count++;
}
Rect(const Rect& r) // 拷貝構造函數
{
width = r.width;
height = r.height;
count++; // 計數器加1
}
~Rect() // 析構函數，計數器減1
{
count--;
}
static int getCount() // 返回計數器的值
{
return count;
}
private:
int width;
int height;
static int count; // 一靜態成員作爲計數器
};
二、淺拷貝
所謂淺拷貝，指的是在對象複製時，只對對象中的數據成員進行簡單的賦值，默認拷貝構造函數執行的也是淺拷貝。大多數狀況下「淺拷貝」已經能很好地工做了，可是一旦對象存在了動態成員，那麼淺拷貝就會出問題了。讓咱們考慮以下一段代碼：
class Rect
{
public:
Rect() // 構造函數，p指向堆中分配的一空間
{
p = new int(100);
}
~Rect() // 析構函數，釋放動態分配的空間
{
if(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指向的空間有相同的值，解決辦法就是使用「深拷貝」。
三、深拷貝
在「深拷貝」的狀況下，對於對象中動態成員，就不能僅僅簡單地賦值了，而應該從新動態分配空間，如上面的例子就應該按照以下的方式進行處理：
class Rect
{
public:
Rect() // 構造函數，p指向堆中分配的一空間
{
p = new int(100);
}
Rect(const Rect& r)
{
width = r.width;
height = r.height;
p = new int; // 爲新對象從新動態分配空間
*p = *(r.p);
}
~Rect() // 析構函數，釋放動態分配的空間
{
if(p != NULL)
{
delete p;
}
}
private:
int width;
int height;
int *p; // 一指針成員
};
此時，在完成對象的複製後，內存的一個大體狀況以下：
此時，rect1的p和rect2的p各自指向一段內存空間，但它們指向的空間具備相同的內容，這就是所謂的「深拷貝」。
三、防止默認拷貝發生
經過對對象複製的分析，咱們發現對象的複製大多在進行「值傳遞」時發生，這裏有一個小技巧能夠防止按值傳遞——聲明一個私有拷貝構造函數。甚至沒必要去定義這個拷貝構造函數，這就由於拷貝構造函數是私有的，若是用戶試圖按值傳遞或函數返回該類對象，將獲得一個編譯錯誤，從而能夠避免按值傳遞或返回對象。
// 防止按值傳遞
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、拷貝構造函數的幾個細節
一、拷貝構造函數裏能調用private成員變量嗎？
解答：這個問題是在網上見的，當時一會兒有點暈。其時從名子咱們就知道拷貝構造函數其時就是一個特殊的構造函數，操做的仍是本身類的成員變量，因此不受private的限制。
二、如下函數哪一個是拷貝構造函數，爲何？
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&
且沒有其它參數或其它參數都有默認值，那麼這個函數是拷貝構造函數。
X::X(const X&); //是拷貝構造函數 X::X(X&, int=1); //是拷貝構造函數 X::X(X&, int a=1, int b=2); //固然也是拷貝構造函數
三、一個類中能夠存在多於一個的拷貝構造函數嗎？
解答：類中能夠存在超過一個拷貝構造函數。
class X {
public:
X(const X&); // const 的拷貝構造
X(X&); // 非const的拷貝構造
};
注意：若是一個類中只存在一個參數爲X&的拷貝構造函數，那麼就不能使用const X或volatile X的對象實行拷貝初始化。
class X {
public:
X();
X(X&);
};
const X cx;
X x = cx; // error
若是一個類中沒有定義拷貝構造函數，那麼編譯器會自動產生一個默認的拷貝構造函數。
這個默認的參數可能爲X::X(const X&)或X::X(X&)，由編譯器根據上下文決定選擇哪個。
- 1. 拷貝構造函數 淺拷貝構造函數 深拷貝構造函數
- 2. C++拷貝構造函數、構造函數和析構函數
- 3. C++拷貝構造函數詳解
- 4. c++拷貝構造函數詳解
- 5. c++_拷貝構造函數
- 6. [C++]拷貝構造函數
- 7. C++之構造函數-拷貝構造
- 8. C++中構造函數，拷貝構造函數和賦值函數的詳解
- 9. c++拷貝構造函數(深拷貝，淺拷貝)詳解
- 10. C++構造函數/析構函數/拷貝構造函數/深拷貝淺拷貝解析
- 更多相關文章...
- • Swift 構造過程 - Swift 教程
- • 構造ICMP數據包 - TCP/IP教程
- • Flink 數據傳輸及反壓詳解
- • TiDB 在摩拜單車在線數據業務的應用和實踐
-
每一个你不满意的现在，都有一个你没有努力的曾经。