內容整理自：

函式原型

在C++中建立一個類，這個類中肯定會包括建構函式、解構函式、複製建構函式和過載賦值操作。

複製建構函式是一種特殊的建構函式，其作用也是為類的成員初始化以及為物件的構造分配儲存空間。函式的名稱必須和類名稱一致，無返回型別，它的唯一的一個引數是本型別的一個引用變數，該引數是const型別，不可變。

複製建構函式原型如下：

class_name(const class_name &src);

對於一個類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_name& operator=(const class_name &src);

複製建構函式與過載賦值操作符的呼叫

當類的物件需要拷貝時，複製建構函式將會被呼叫。以下情況都會呼叫複製建構函式：
一個物件以值傳遞的方式傳入函式體；
一個物件以值傳遞的方式從函式返回；
一個物件需要通過另外一個物件進行初始化。

如果物件在宣告的同時將另一個已存在的物件賦給它，就會呼叫複製建構函式；如果物件已經存在了，然後再將另一個已存在的物件賦給它，呼叫的就是過載賦值運算子。

#include <iostream>
using namespace std;

class CTest
{
public:
     CTest(){}
     ~CTest(){}

     CTest(const CTest &test)
     {
          cout<<"copy constructor."<<endl;
     }

     void operator=(const CTest &test)
     {
          cout<<"operator="<<endl;
     }

     void Test(CTest test)
     {}

     CTest Test2()
     {
          CTest a;
          return a;
     }

     void Test3(CTest &test)
     {}

     CTest &Test4()
     {
          CTest *pA = new CTest;
          return *pA;
     }
};

int main()
{
     CTest obj;

     CTest obj1(obj); // 呼叫複製建構函式

     obj1 = obj; // 呼叫過載賦值操作符

     /* 傳參的過程中，要呼叫一次複製建構函式
     * obj1入棧時會呼叫複製建構函式建立一個臨時物件，與函式內的區域性變數具有相同的作用域
     */
     obj.Test(obj1);

     /* 函式返回值時，呼叫複製建構函式；將返回值賦值給obj2時，呼叫過載賦值操作符
     * 函式返回值時，也會構造一個臨時物件；呼叫複製建構函式將返回值複製到臨時物件上
     */
     CTest obj2;
     obj2 = obj.Test2();

     obj2.Test3(obj); // 引數是引用，沒有呼叫複製建構函式

     CTest obj3;
     obj2.Test4(); // 返回值是引用，沒有呼叫複製建構函式

     return 0;
}
 

深拷貝(deep copy)與淺拷貝(shallow copy)

如果在類中沒有顯式地宣告，那麼編譯器會自動生成預設的複製建構函式和過載賦值操作符。預設的複製建構函式和賦值運算子進行的都是“shallow copy”，只是簡單地複製欄位，把值一一賦給要拷貝的值。因此如果物件中含有動態分配的記憶體，就需要我們自己重寫複製建構函式和過載賦值操作符來實現“deep copy”，確保資料的完整性和安全性。

例如：類內成員變數需要動態開闢堆記憶體，如果實行淺拷貝，也就是把物件裡的值完全複製給另一個物件，如A=B。這時，如果B中有一個成員變數指標已經申請了記憶體，那A中的那個成員變數也指向同一塊記憶體。這就出現了問題：當B把記憶體釋放了（如：析構），這時A內的指標就是野指標了，出現執行錯誤。

深拷貝和淺拷貝可以簡單理解為：如果一個類擁有資源(堆，或者是其它系統資源)，當這個類的物件發生複製過程的時候，資源重新分配，使物件擁有不同的資源，但資源的內容是一樣的，這個過程就是深拷貝；反之，沒有重新分配資源，兩個物件就有用共同的資源，同時對資源可以訪問，就是淺拷貝。淺拷貝，只是對指標的拷貝，拷貝後兩個指標指向同一個記憶體空間，深拷貝不但對指標進行拷貝，而且對指標指向的內容進行拷貝，經深拷貝後的指標是指向兩個不同地址的指標。

#include <iostream>
using namespace std;
class CA
{
　public:
　　CA(int b,char* cstr)
　　{
　　　a=b;
　　　str=new char[b];
　　　strcpy(str,cstr);
　　}
　　CA(const CA& C)
　　{
　　　a=C.a;
　　　str=new char[a]; //深拷貝
　　　if(str!=0)
　　　　strcpy(str,C.str);
　　}
　　void Show()
　　{
　　　cout<<str<<endl;
　　}
　　~CA()
　　{
　　　delete str;
　　}
　private:
　　int a;
　　char *str;
};

int main()
{
　CA A(10,"Hello!");
　CA B=A;
　B.Show();
　return 0;
} 

三法則（英語：rule of three，the Law of The Big Three，The Big Three；三法則，三大定律）在 C++ 程式設計裡，它是一個以設計的基本原則而制定的定律，三法則的要求在於，假如型別有明顯地定義下列其中一個成員函式，那麼程式設計師必須連其他二個成員函式也一同編寫至型別內，亦即下列三個成員函式缺一不可：

• 解構函式（Destructor）
• 複製建構函式（copy constructor）
• 複製賦值運算子（copy assignment operator）

有時候為了防止預設拷貝發生，可以將複製建構函式和過載賦值運算子設為private來禁止拷貝，並且只是宣告，不用實現。這樣的話，如果試圖呼叫 A  b(a); 就呼叫了私有的複製建構函式，編譯器會報錯。

class Widget  
{  
public:  
    int* pi;  
private:  
    Widget(const Widget&);  
    Widget& operator=(const Widget&);  
}; 

這種方法的一點小缺陷是，如果該類的成員函式或其友元函式呼叫複製建構函式或賦值操作符函式，會將錯誤推後到連線期。有一種方法可以將連線期錯誤移至編譯期：先定義一個基類，然後讓你的類繼承該類。