拷贝构造函数
一. 拷貝構(gòu)造函數(shù)
1 #include<iostream>
2 using namespace std;
3 class CExample
4 {
5 private:
6 int a;
7 public:
8 //構(gòu)造函數(shù)
9 CExample(int b)
10 {
11 a=b;
12 printf("constructor is called
");
13 }
14 //拷貝構(gòu)造函數(shù)
15 CExample(const CExample & c)
16 {
17 a=c.a;
18 printf("copy constructor is called
");
19 }
20 //析構(gòu)函數(shù)
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
就類對象而言，相同類型的類對象是通過拷貝構(gòu)造函數(shù)來完成整個復(fù)制過程的。
運行程序，屏幕輸出100。從以上代碼的運行結(jié)果可以看出，系統(tǒng)為對象 B 分配了內(nèi)存并完成了與對象 A 的復(fù)制過程。
CExample(const CExample& C) 就是我們自定義的拷貝構(gòu)造函數(shù)?？梢姡截悩?gòu)造函數(shù)是一種特殊的構(gòu)造函數(shù)，函數(shù)的名稱必須和類名稱一致，它必須的一個參數(shù)是本類型的一個引用變量。
二、拷貝構(gòu)造函數(shù)的調(diào)用時機
1 當函數(shù)的參數(shù)為類的對象時
2 函數(shù)的返回值是類的對象
3 對象需要通過另外一個同類型的對象進行初始化
三. 深拷貝和淺拷貝
1. 默認拷貝構(gòu)造函數(shù)
很多時候在我們都不知道拷貝構(gòu)造函數(shù)的情況下，傳遞對象給函數(shù)參數(shù)或者函數(shù)返回對象都能很好的進行，
這是因為編譯器會給我們自動產(chǎn)生一個拷貝構(gòu)造函數(shù)，這就是“默認拷貝構(gòu)造函數(shù)”，這個構(gòu)造函數(shù)很簡單，
僅僅使用“老對象”的數(shù)據(jù)成員的值對“新對象”的數(shù)據(jù)成員一一進行賦值，它一般具有以下形式：
Rect::Rect(const Rect& r)
{
width=r.width;
height=r.height;
}
當然，以上代碼不用我們編寫，編譯器會為我們自動生成。但是如果認為這樣就可以解決對象的復(fù)制問題，那就錯了，讓我們來考慮以下一段代碼：
#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
這段代碼對前面的類，加入了一個靜態(tài)成員，目的是進行計數(shù)。在主函數(shù)中，首先創(chuàng)建對象rect1，輸出此時的對象個數(shù)，然后使用rect1復(fù)制出對象rect2，再輸出此時的對象個數(shù)，按照理解，此時應(yīng)該有兩個對象存在，但實際程序運行時，輸出的都是1，反應(yīng)出只有1個對象。此外，在銷毀對象時，由于會調(diào)用銷毀兩個對象，類的析構(gòu)函數(shù)會調(diào)用兩次，此時的計數(shù)器將變?yōu)樨摂?shù)。說白了，就是拷貝構(gòu)造函數(shù)沒有處理靜態(tài)數(shù)據(jù)成員。
出現(xiàn)這些問題最根本就在于在復(fù)制對象時，計數(shù)器沒有遞增，我們重新編寫拷貝構(gòu)造函數(shù)，如下：
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.淺拷貝
所謂淺拷貝，指的是在對象復(fù)制時，只對對象中的數(shù)據(jù)成員進行簡單的賦值，默認拷貝構(gòu)造函數(shù)執(zhí)行的也是淺拷貝。大多情況下“淺拷貝”已經(jīng)能很好地工作了，但是一旦對象存在了動態(tài)成員，那么淺拷貝就會出問題了，讓我們考慮如下一段代碼：
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
在這段代碼運行結(jié)束之前，會出現(xiàn)一個運行錯誤。原因就在于在進行對象復(fù)制時，對于動態(tài)分配的內(nèi)容沒有進行正確的操作。我們來分析一下：
在運行定義rect1對象后，由于在構(gòu)造函數(shù)中有一個動態(tài)分配的語句，因此執(zhí)行后的內(nèi)存情況大致如下：
在使用rect1復(fù)制rect2時，由于執(zhí)行的是淺拷貝，只是將成員的值進行賦值，這時rect1.p= rect2.p，也即這兩個指針指向了堆里的同一個空間，如下圖所示：
當然，這不是我們所期望的結(jié)果，在銷毀對象時，兩個對象的析構(gòu)函數(shù)將對同一個內(nèi)存空間釋放兩次，這就是錯誤出現(xiàn)的原因。我們需要的不是兩個p有相同的值，而是兩個p指向的空間有相同的值，解決辦法就是使用“深拷貝”。
3. 深拷貝
在“深拷貝”的情況下，對于對象中動態(tài)成員，就不能僅僅簡單地賦值了，而應(yīng)該重新動態(tài)分配空間，如上面的例子就應(yīng)該按照如下的方式進行處理：
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
此時，在完成對象的復(fù)制后，內(nèi)存的一個大致情況如下：
此時rect1的p和rect2的p各自指向一段內(nèi)存空間，但它們指向的空間具有相同的內(nèi)容，這就是所謂的“深拷貝”。
3. 防止默認拷貝發(fā)生
通過對對象復(fù)制的分析，我們發(fā)現(xiàn)對象的復(fù)制大多在進行“值傳遞”時發(fā)生，這里有一個小技巧可以防止按值傳遞——聲明一個私有拷貝構(gòu)造函數(shù)。甚至不必去定義這個拷貝構(gòu)造函數(shù)，這樣因為拷貝構(gòu)造函數(shù)是私有的，如果用戶試圖按值傳遞或函數(shù)返回該類對象，將得到一個編譯錯誤，從而可以避免按值傳遞或返回對象。
1 //防止按值傳遞
2 class CExample
3 {
4 private:
5 int a;
6
7 public:
8 //構(gòu)造函數(shù)
9 CExample(int b)
10 {
11 a = b;
12 cout<<"creat: "<<a<<endl;
13 }
14
15 private:
16 //拷貝構(gòu)造函數(shù)，只是聲明
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
小結(jié)：
拷貝有兩種：深拷貝，淺拷貝。
當出現(xiàn)類的等號賦值時，會調(diào)用拷貝函數(shù)，在未定義顯示拷貝構(gòu)造函數(shù)的情況下，系統(tǒng)會調(diào)用默認的拷貝函數(shù)——即淺拷貝，它能夠完成成員的一一復(fù)制。當數(shù)據(jù)成員中沒有指針時，淺拷貝是可行的。但當數(shù)據(jù)成員中有指針時，如果采用簡單的淺拷貝，則兩類中的兩個指針將指向同一個地址，當對象快結(jié)束時，會調(diào)用兩次析構(gòu)函數(shù)，而導(dǎo)致指針懸掛現(xiàn)象。所以，這時，必須采用深拷貝。
深拷貝與淺拷貝的區(qū)別就在于深拷貝會在堆內(nèi)存中另外申請空間來儲存數(shù)據(jù)，從而也就解決了指針懸掛的問題。簡而言之，當數(shù)據(jù)成員中有指針時，必須要用深拷貝。
四、拷貝構(gòu)造函數(shù)的幾個細節(jié)
1.為什么拷貝構(gòu)造函數(shù)必須是引用傳遞，不能是值傳遞？
簡單的回答是為了防止遞歸引用。
具體一些可以這么講：
當一個對象需要以值方式傳遞時，編譯器會生成代碼調(diào)用它的拷貝構(gòu)造函數(shù)以生成一個復(fù)本。如果類A的拷貝構(gòu)造函數(shù)是以值方式傳遞一個類A對象作為參數(shù)的話，當需要調(diào)用類A的拷貝構(gòu)造函數(shù)時，需要以值方式傳進一個A的對象作為實參；而以值方式傳遞需要調(diào)用類A的拷貝構(gòu)造函數(shù)；結(jié)果就是調(diào)用類A的拷貝構(gòu)造函數(shù)導(dǎo)致又一次調(diào)用類A的拷貝構(gòu)造函數(shù)，這就是一個無限遞歸。
2. 拷貝構(gòu)造函數(shù)的作用。
作用就是用來復(fù)制對象的，在使用這個對象的實例來初始化這個對象的一個新的實例。
3.參數(shù)傳遞過程到底發(fā)生了什么？
將地址傳遞和值傳遞統(tǒng)一起來，歸根結(jié)底還是傳遞的是"值"(地址也是值，只不過通過它可以找到另一個值)！
i)值傳遞:
對于內(nèi)置數(shù)據(jù)類型的傳遞時，直接賦值拷貝給形參(注意形參是函數(shù)內(nèi)局部變量)；
對于類類型的傳遞時，需要首先調(diào)用該類的拷貝構(gòu)造函數(shù)來初始化形參(局部對象)；如voidfoo(class_typeobj_local){},如果調(diào)用foo(obj);首先class_typeobj_local(obj),這樣就定義了局部變量obj_local供函數(shù)內(nèi)部使用
ii)引用傳遞:
無論對內(nèi)置類型還是類類型，傳遞引用或指針最終都是傳遞的地址值！而地址總是指針類型(屬于簡單類型),顯然參數(shù)傳遞時，按簡單類型的賦值拷貝，而不會有拷貝構(gòu)造函數(shù)的調(diào)用(對于類類型).
4. 在類中有指針數(shù)據(jù)成員時，拷貝構(gòu)造函數(shù)的使用？
如果不顯式聲明拷貝構(gòu)造函數(shù)的時候，編譯器也會生成一個默認的拷貝構(gòu)造函數(shù)，而且在一般的情況下運行的也很好。但是在遇到類有指針數(shù)據(jù)成員時就出現(xiàn)問題了：因為默認的拷貝構(gòu)造函數(shù)是按成員拷貝構(gòu)造，這導(dǎo)致了兩個不同的指針(如ptr1=ptr2)指向了相同的內(nèi)存。當一個實例銷毀時，調(diào)用析構(gòu)函數(shù)free(ptr1)釋放了這段內(nèi)存，那么剩下的一個實例的指針ptr2就無效了，在被銷毀的時候free(ptr2)就會出現(xiàn)錯誤了,這相當于重復(fù)釋放一塊內(nèi)存兩次。這種情況必須顯式聲明并實現(xiàn)自己的拷貝構(gòu)造函數(shù)，來為新的實例的指針分配新的內(nèi)存。
問題1和2回答了為什么拷貝構(gòu)造函數(shù)使用值傳遞會產(chǎn)生無限遞歸調(diào)用的問題；
問題3回答了回答了在類中有指針數(shù)據(jù)成員時，拷貝構(gòu)造函數(shù)使用值傳遞等于白顯式定義了拷貝構(gòu)造函數(shù)，因為默認的拷貝構(gòu)造函數(shù)就是這么干的。
5. 拷貝構(gòu)造函數(shù)里能調(diào)用private成員變量嗎?
解答：這個問題是在網(wǎng)上見的，當時一下子有點暈。其時從名子我們就知道拷貝構(gòu)造函數(shù)其時就是一個特殊的構(gòu)造函數(shù)，操作的還是自己類的成員變量，所以不受private的限制。
6.以下函數(shù)哪個是拷貝構(gòu)造函數(shù),為什么?
X::X(const X&); //拷貝構(gòu)造函數(shù) X::X(X); X::X(X&, int a=1); //拷貝構(gòu)造函數(shù) X::X(X&, int a=1, int b=2); //拷貝構(gòu)造函數(shù)
解答：對于一個類X, 如果一個構(gòu)造函數(shù)的第一個參數(shù)是下列之一:
a) X&
b) const X&
c) volatile X&
d) const volatile X&
且沒有其他參數(shù)或其他參數(shù)都有默認值,那么這個函數(shù)是拷貝構(gòu)造函數(shù).
7. 一個類中可以存在多于一個的拷貝構(gòu)造函數(shù)嗎?
解答：類中可以存在超過一個拷貝構(gòu)造函數(shù)。
class X {
public:
X(const X&); // const 的拷貝構(gòu)造
X(X&); // 非const的拷貝構(gòu)造
};
注意,如果一個類中只存在一個參數(shù)為 X& 的拷貝構(gòu)造函數(shù),那么就不能使用const X或volatile X的對象實行拷貝初始化.
如果一個類中沒有定義拷貝構(gòu)造函數(shù),那么編譯器會自動產(chǎn)生一個默認的拷貝構(gòu)造函數(shù)。
這個默認的參數(shù)可能為X::X(const X&)或X::X(X&),由編譯器根據(jù)上下文決定選擇哪一個。
五、C++構(gòu)造函數(shù)以及析構(gòu)函數(shù)的若干面試問題
Q1：構(gòu)造函數(shù)能否重載，析構(gòu)函數(shù)能否重載，為什么？
A1：構(gòu)造函數(shù)可以，析構(gòu)函數(shù)不可以。
Q2：析構(gòu)函數(shù)為什么一般情況下要聲明為虛函數(shù)？
A2：虛函數(shù)是實現(xiàn)多態(tài)的基礎(chǔ)，當我們通過基類的指針是析構(gòu)子類對象時候，如果不定義成虛函數(shù)，那只調(diào)用基類的析構(gòu)函數(shù)，子類的析構(gòu)函數(shù)將不會被調(diào)用。如 果定義為虛函數(shù)，則子類父類的析構(gòu)函數(shù)都會被調(diào)用。
Q3：什么情況下必須定義拷貝構(gòu)造函數(shù)？
A3：當類的對象用于函數(shù)值傳遞時（值參數(shù)，返回類對象），拷貝構(gòu)造函數(shù)會被調(diào)用。如果對象復(fù)制并非簡單的值拷貝，那就必須定義拷貝構(gòu)造函數(shù)。例如大的堆 棧數(shù)據(jù)拷貝。如果定義了拷貝構(gòu)造函數(shù)，那也必須重載賦值操作符。
總結(jié)
- 上一篇： 数据结构实验：哈希表
- 下一篇： Java程序通过代理访问网络