一、什麼是拷貝構造函數
首先對于普通類型的對象來說，它們之間的複制是很簡單的，例如：
int a=100;
int b=a; 而類對象與普通對象不同，類對象内部結構一般較為複雜，存在各種成員變量。
下面看一個類對象拷貝的簡單例子。
#include<iostream>
using namespace std;
class CExample
{
private:
int a;
public:
//構造函數
CExample(int b)
{
a=b;
printf("constructor is called\n");
}
//拷貝構造函數
CExample(const CExample & c)
{
a=c.a;
printf("copy constructor is called\n");
}
//析構函數
~CExample()
{
cout<<"destructor is called\n";
}
void Show()
{
cout<<a<<endl;
}
};
int main()
{
CExample A(100);
CExample B=A;
B.Show();
return 0;
} 運作程式，螢幕輸出100。從以上代碼的運作結果可以看出，系統為對象 B 配置設定了記憶體并完成了與對象 A 的複制過程。就類對象而言，相同類型的類對象是通過拷貝構造函數來完成整個複制過程的。
CExample(const CExample& C) 就是我們自定義的拷貝構造函數。可見，拷貝構造函數是一種特殊的構造函數，函數的名稱必須和類名稱一緻，它必須的一個參數是本類型的一個引用變量。
二、拷貝構造函數的調用時機
1. 當函數的參數為類的對象時
#include<iostream>
using namespace std;
class CExample
{
private:
int a;
public:
CExample(int b)
{
a=b;
printf("constructor is called\n");
}
CExample(const CExample & c)
{
a=c.a;
printf("copy constructor is called\n");
}
~CExample()
{
cout<<"destructor is called\n";
}
void Show()
{
cout<<a<<endl;
}
};
void g_fun(CExample c)
{
cout<<"g_func"<<endl;
}
int main()
{
CExample A(100);
CExample B=A;
B.Show();
g_fun(A);
return 0;
} 調用g_fun()時，會産生以下幾個重要步驟：
(1).A對象傳入形參時，會先會産生一個臨時變量，就叫 C 吧。
(2).然後調用拷貝構造函數把A的值給C。 整個這兩個步驟有點像：CExample C(A);
(3).等g_fun()執行完後, 析構掉 C 對象。
2. 函數的傳回值是類的對象
#include<iostream>
using namespace std;
class CExample
{
private:
int a;
public:
//構造函數
CExample(int b)
{
a=b;
printf("constructor is called\n");
}
//拷貝構造函數
CExample(const CExample & c)
{
a=c.a;
printf("copy constructor is called\n");
}
//析構函數
~CExample()
{
cout<<"destructor is called\n";
}
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對象。
3. 對象需要通過另外一個對象進行初始化
CExample A(100);
CExample B=A; 三、淺拷貝與深拷貝
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;
}
這段代碼對前面的類，加入了一個靜态成員，目的是進行計數。在主函數中，首先建立對象rect1，輸出此時的對象個數，然後使用rect1複制出對象rect2，再輸出此時的對象個數，按照了解，此時應該有兩個對象存在，但實際程式運作時，輸出的都是1，反應出隻有1個對象。此外，在銷毀對象時，由于會調用銷毀兩個對象，類的析構函數會調用兩次，此時的計數器将變為負數。
說白了，就是拷貝構造函數沒有處理靜态資料成員。
出現這些問題最根本就在于在複制對象時，計數器沒有遞增，我們重新編寫拷貝構造函數，如下：
#include<iostream>
using namespace std;
class Rect
{
public:
Rect()
{
count++;
}
Rect(const Rect& r)
{
width=r.width;
height=r.height;
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;
} 2. 淺拷貝
所謂淺拷貝，指的是在對象複制時，隻對對象中的資料成員進行簡單的指派，預設拷貝構造函數執行的也是淺拷貝。大多情況下“淺拷貝”已經能很好地工作了，但是一旦對象存在了動态成員，那麼淺拷貝就會出問題了，讓我們考慮如下一段代碼：
#include<iostream>
#include<assert.h>
using namespace std;
class Rect
{
public:
Rect()
{
p=new int(100);
}
~Rect()
{
assert(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指向的空間有相同的值，解決辦法就是使用“深拷貝”。
3. 深拷貝
在“深拷貝”的情況下，對于對象中動态成員，就不能僅僅簡單地指派了，而應該重新動态配置設定空間，如上面的例子就應該按照如下的方式進行處理：
#include<iostream>
#include<assert.h>
using namespace std;
class Rect
{
public:
Rect()
{
p=new int(100);
}
Rect(const Rect& r)
{
width=r.width;
height=r.height;
p=new int(100);
*p=*(r.p);
}
~Rect()
{
assert(p!=NULL);
delete p;
}
private:
int width;
int height;
int *p;
};
int main()
{
Rect rect1;
Rect rect2(rect1);
return 0;
} 此時，在完成對象的複制後，記憶體的一個大緻情況如下：
此時rect1的p和rect2的p各自指向一段記憶體空間，但它們指向的空間具有相同的内容，這就是所謂的“深拷貝”。
3. 防止預設拷貝發生
通過對對象複制的分析，我們發現對象的複制大多在進行“值傳遞”時發生，這裡有一個小技巧可以防止按值傳遞——聲明一個私有拷貝構造函數。甚至不必去定義這個拷貝構造函數，這樣因為拷貝構造函數是私有的，如果使用者試圖按值傳遞或函數傳回該類對象，将得到一個編譯錯誤，進而可以避免按值傳遞或傳回對象。
//防止按值傳遞
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;
} 小結：
拷貝有兩種：深拷貝，淺拷貝。
四、拷貝構造函數的幾個細節
1.為什麼拷貝構造函數必須是引用傳遞，不能是值傳遞？
簡單的回答是為了防止遞歸引用。
具體一些可以這麼講：
當 一個對象需要以值方式傳遞時，編譯器會生成代碼調用它的拷貝構造函數以生成一個複本。如果類A的拷貝構造函數是以值方式傳遞一個類A對象作為參數的話，當 需要調用類A的拷貝構造函數時，需要以值方式傳進一個A的對象作為實參； 而以值方式傳遞需要調用類A的拷貝構造函數；結果就是調用類A的拷貝構造函數導 緻又一次調用類A的拷貝構造函數，這就是一個無限遞歸。
2. 拷貝構造函數的作用。
作用就是用來複制對象的，在使用這個對象的執行個體來初始化這個對象的一個新的執行個體。
3.參數傳遞過程到底發生了什麼？
将位址傳遞和值傳遞統一起來，歸根結底還是傳遞的是"值"(位址也是值，隻不過通過它可以找到另一個值)！
i)值傳遞:
對于内置資料類型的傳遞時，直接指派拷貝給形參(注意形參是函數内局部變量)；
對于類類型的傳遞時，需要首先調用該類的拷貝構造函數來初始化形參(局部對象)；如void foo(class_type obj_local){}, 如果調用foo(obj); 首先class_type obj_local(obj) ,這樣就定義了局部變量obj_local供函數内部使用
ii)引用傳遞:
無論對内置類型還是類類型，傳遞引用或指針最終都是傳遞的位址值！而位址總是指針類型(屬于簡單類型), 顯然參數傳遞時，按簡單類型的指派拷貝，而不會有拷貝構造函數的調用(對于類類型).
4. 在類中有指針資料成員時，拷貝構造函數的使用？
如果不顯式聲明拷貝構造函數的時候，編譯器也會生成一個預設的拷貝構造函數，而且在一般的情況下運作的也很好。但是在遇到類有指針資料成員時就出現問題 了：因為預設的拷貝構造函數是按成員拷貝構造，這導緻了兩個不同的指針(如ptr1=ptr2)指向了相同的記憶體。當一個執行個體銷毀時，調用析構函數 free(ptr1)釋放了這段記憶體，那麼剩下的一個執行個體的指針ptr2就無效了，在被銷毀的時候free(ptr2)就會出現錯誤了, 這相當于重複釋放一塊記憶體兩次。這種情況必須顯式聲明并實作自己的拷貝構造函數，來為新的執行個體的指針配置設定新的記憶體。
問題1和2回答了為什麼拷貝構造函數使用值傳遞會産生無限遞歸調用的問題；
問題3回答了回答了在類中有指針資料成員時，拷貝構造函數使用值傳遞等于白顯式定義了拷貝構造函數，因為預設的拷貝構造函數就是這麼幹的。
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：當類的對象用于函數值傳遞時（值參數，傳回類對象），拷貝構造函數會被調用。如果對象複制并非簡單的值拷貝，那就必須定義拷貝構造函數。例如大的堆 棧資料拷貝。如果定義了拷貝構造函數，那也必須重載指派操作符。