探討C++中對象的“淺拷貝”與“深拷貝”

C++中對象的複製就如同“複製”，用一個已有的對象快速地複製出多個完全相同的對象。一般而言，以下三種情況都會使用到對象的複製：

    （1）建立一個新對象，並用另一個同類的已有對象對新對象進行初始化，例如：

class Rect { private:     int width;     int height; }; Rect rect1; Rect rect2(rect1);  // 使用rect1初始化rect2，此時會進行對象的複製

    （2）當函數的參數為類的對象時，這時調用此函數時使用的是值傳遞，也會產生對象的複製，例如：

void fun1(Rect rect) {     ... } int main() {     Rect rect1;     fun1(rect1);    // 此時會進行對象的複製     return 0; }

    （3）函數的傳回值是類的對象時，在函數調用結束時，需要將函數中的對象複製一個臨時對象並傳給改函數的調用處，例如：

Rect fun2() {     Rect rect;     return rect; } int main() {     Rect rect1;     rect1=fun2();     // 在fun2返回對象時，會執行對象複製，複製出一臨時對象，     // 然後將此臨時對象“賦值”給rect1     return 0; }

    對象的複製都是通過一種特殊的建構函式來完成的，這種特殊的建構函式就是拷貝建構函式（copy constructor，也叫複製建構函式）。拷貝建構函式在大多數情況下都很簡單，甚至在我們都不知道它存在的情況下也能很好發揮作用，但是在一些特殊情況下，特別是在對象裡有動態成員的時候，就需要我們特別小心地處理拷貝建構函式了。下面我們就來看看拷貝建構函式的使用。

    一、預設拷貝建構函式

    很多時候在我們都不知道拷貝建構函式的情況下，傳遞對象給函數參數或者函數返回對象都能很好的進行，這是因為編譯器會給我們自動產生一個拷貝建構函式，這就是“預設拷貝建構函式”，這個建構函式很簡單，僅僅使用“老對象”的資料成員的值對“新對象”的資料成員一一進行賦值，它一般具有以下形式：

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各自指向一段記憶體空間，但它們指向的空間具有相同的內容，這就是所謂的“深拷貝”。

    此外，在與“對象的複製”很類似的“對象的賦值”的情況下，也會出現同樣的問題。在“對象的賦值”一文中再來討論此問題。

    通過對對象複製的分析，我們發現對象的複製大多在進行“值傳遞”時發生，這裡有一個小技巧可以防止按值傳遞——聲明一個私人拷貝建構函式。甚至不必去定義這個拷貝建構函式，這樣因為拷貝建構函式是私人的，如果使用者試圖按值傳遞或函數返回該類對象，將得到一個編譯錯誤，從而可以避免按值傳遞或返回對象。