一. 什麼是拷貝構造函數
首先對于普通類型的對象來說,它們之間的複制是很簡單的,例如:
[c-sharp] view
plaincopy
int a = 100;
int b = a;
而類對象與普通對象不同,類對象内部結構一般較為複雜,存在各種成員變量。
下面看一個類對象拷貝的簡單例子。
#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 的複制過程。就類對象而言,相同類型的類對象是通過拷貝構造函數來完成整個複制過程的。
下面舉例說明拷貝構造函數的工作過程。
int a;
//構造函數
cexample(int b)
{ a = b;}
//拷貝構造函數
cexample(const cexample& c)
{
a = c.a;
}
//一般函數
void show ()
cexample a(100);
cexample b = a; // cexample b(a); 也是一樣的
b.show ();
return 0;
}
cexample(const cexample& c) 就是我們自定義的拷貝構造函數。可見,拷貝構造函數是一種特殊的構造函數,函數的名稱必須和類名稱一緻,它必須的一個參數是本類型的一個引用變量。
二. 拷貝構造函數的調用時機
在c++中,下面三種對象需要調用拷貝構造函數!
1. 對象以值傳遞的方式傳入函數參數
class cexample
int a;
//構造函數
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;
cexample test(1);
//傳入對象
g_fun(test);
return 0;
調用g_fun()時,會産生以下幾個重要步驟:
(1).test對象傳入形參時,會先會産生一個臨時變量,就叫 c 吧。
(2).然後調用拷貝構造函數把test的值給c。 整個這兩個步驟有點像:cexample c(test);
(3).等g_fun()執行完後, 析構掉 c 對象。
2. 對象以值傳遞的方式從函數傳回
{
//全局函數
cexample g_fun()
cexample temp(0);
return temp;
g_fun();
當g_fun()函數執行到return時,會産生以下幾個重要步驟:
(1). 先會産生一個臨時變量,就叫xxxx吧。
(2). 然後調用拷貝構造函數把temp的值給xxxx。整個這兩個步驟有點像:cexample xxxx(temp);
(3). 在函數執行到最後先析構temp局部變量。
(4). 等g_fun()執行完後再析構掉xxxx對象。
3. 對象需要通過另外一個對象進行初始化;
cexample a(100);
cexample b = a;
// cexample b(a);
後兩句都會調用拷貝構造函數。
三. 淺拷貝和深拷貝
1. 預設拷貝構造函數
很多時候在我們都不知道拷貝構造函數的情況下,傳遞對象給函數參數或者函數傳回對象都能很好的進行,這是因為編譯器會給我們自動産生一個拷貝構造函數,這就是“預設拷貝構造函數”,這個構造函數很簡單,僅僅使用“老對象”的資料成員的值對“新對象”的資料成員一一進行指派,它一般具有以下形式:
rect::rect(const rect& r)
width = r.width;
height = r.height;
當然,以上代碼不用我們編寫,編譯器會為我們自動生成。但是如果認為這樣就可以解決對象的複制問題,那就錯了,讓我們來考慮以下一段代碼:
class rect
rect() // 構造函數,計數器加1
count++;
~rect() // 析構函數,計數器減1
count--;
static int getcount() // 傳回計數器的值
return count;
int width;
int height;
static int count; // 一靜态成員做為計數器
int rect::count = 0; // 初始化計數器
rect rect1;
cout<<"the count of rect: "<<rect::getcount()<<endl;
rect rect2(rect1); // 使用rect1複制rect2,此時應該有兩個對象
cout<<"the count of rect: "<<rect::getcount()<<endl;
這段代碼對前面的類,加入了一個靜态成員,目的是進行計數。在主函數中,首先建立對象rect1,輸出此時的對象個數,然後使用rect1複制出對象rect2,再輸出此時的對象個數,按照了解,此時應該有兩個對象存在,但實際程式運作時,輸出的都是1,反應出隻有1個對象。此外,在銷毀對象時,由于會調用銷毀兩個對象,類的析構函數會調用兩次,此時的計數器将變為負數。
說白了,就是拷貝構造函數沒有處理靜态資料成員。
出現這些問題最根本就在于在複制對象時,計數器沒有遞增,我們重新編寫拷貝構造函數,如下:
rect(const rect& r) // 拷貝構造函數
width = r.width;
height = r.height;
count++; // 計數器加1
static int getcount() // 傳回計數器的值
2. 淺拷貝
所謂淺拷貝,指的是在對象複制時,隻對對象中的資料成員進行簡單的指派,預設拷貝構造函數執行的也是淺拷貝。大多情況下“淺拷貝”已經能很好地工作了,但是一旦對象存在了動态成員,那麼淺拷貝就會出問題了,讓我們考慮如下一段代碼:
rect() // 構造函數,p指向堆中配置設定的一空間
p = new int(100);
~rect() // 析構函數,釋放動态配置設定的空間
if(p != null)
{
delete p;
}
int *p; // 一指針成員
rect rect2(rect1); // 複制對象
在這段代碼運作結束之前,會出現一個運作錯誤。原因就在于在進行對象複制時,對于動态配置設定的内容沒有進行正确的操作。我們來分析一下:
在運作定義rect1對象後,由于在構造函數中有一個動态配置設定的語句,是以執行後的記憶體情況大緻如下:
在使用rect1複制rect2時,由于執行的是淺拷貝,隻是将成員的值進行指派,這時 rect1.p =
rect2.p,也即這兩個指針指向了堆裡的同一個空間,如下圖所示:
當然,這不是我們所期望的結果,在銷毀對象時,兩個對象的析構函數将對同一個記憶體空間釋放兩次,這就是錯誤出現的原因。我們需要的不是兩個p有相同的值,而是兩個p指向的空間有相同的值,解決辦法就是使用“深拷貝”。
3. 深拷貝
在“深拷貝”的情況下,對于對象中動态成員,就不能僅僅簡單地指派了,而應該重新動态配置設定空間,如上面的例子就應該按照如下的方式進行處理:
rect(const rect& r)
p = new int; // 為新對象重新動态配置設定空間
*p = *(r.p);
此時,在完成對象的複制後,記憶體的一個大緻情況如下:
此時rect1的p和rect2的p各自指向一段記憶體空間,但它們指向的空間具有相同的内容,這就是所謂的“深拷貝”。
3. 防止預設拷貝發生
通過對對象複制的分析,我們發現對象的複制大多在進行“值傳遞”時發生,這裡有一個小技巧可以防止按值傳遞——聲明一個私有拷貝構造函數。甚至不必去定義這個拷貝構造函數,這樣因為拷貝構造函數是私有的,如果使用者試圖按值傳遞或函數傳回該類對象,将得到一個編譯錯誤,進而可以避免按值傳遞或傳回對象。
// 防止按值傳遞
{
a = b;
cout<<"creat: "<<a<<endl;
//拷貝構造,隻是聲明
cexample(const cexample& c);
~cexample()
cout<< "delete: "<<a<<endl;
cout<<"test"<<endl;
cexample test(1);
//g_fun(test); 按值傳遞将出錯
四. 拷貝構造函數的幾個細節
1. 拷貝構造函數裡能調用private成員變量嗎?
解答:這個問題是在網上見的,當時一下子有點暈。其時從名子我們就知道拷貝構造函數其時就是一個特殊的構造函數,操作的還是自己類的成員變量,是以不受private的限制。
2. 以下函數哪個是拷貝構造函數,為什麼?
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); //當然也是拷貝構造函數
3. 一個類中可以存在多于一個的拷貝構造函數嗎?
解答:類中可以存在超過一個拷貝構造函數。
class x {
public:
x(const x&); // const 的拷貝構造
x(x&); // 非const的拷貝構造
注意,如果一個類中隻存在一個參數為 x& 的拷貝構造函數,那麼就不能使用const x或volatile x的對象實行拷貝初始化.
class x {
x();
x(x&);
};
const x cx;
x x = cx; // error
如果一個類中沒有定義拷貝構造函數,那麼編譯器會自動産生一個預設的拷貝構造函數。
這個預設的參數可能為 x::x(const x&)或 x::x(x&),由編譯器根據上下文決定選擇哪一個。