批註：C++中複製建構函式與過載賦值操作符總結:預設淺拷貝,帶指標的需要深拷貝

fdsafwagdagadg6576發表於2016-06-20
C++函式賦值指標

前言

這篇文章將對C++中複製建構函式和過載賦值操作符進行總結，包括以下內容：

  1. 複製建構函式和過載賦值操作符的定義；
  2. 複製建構函式和過載賦值操作符的呼叫時機；
  3. 複製建構函式和過載賦值操作符的實現要點；
  4. 複製建構函式的一些細節。

複製建構函式和過載賦值操作符的定義

我們都知道，在C++中建立一個類，這個類中肯定會包括建構函式、解構函式、複製建構函式和過載賦值操作；即使在你沒有明確定義的情況下，編譯器也會給你生成這樣的四個函式。例如以下類：

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

     CTest(const CTest &);
     CTest& operator=(const CTest &);
};

對於建構函式和解構函式不是今天總結的重點，今天的重點是複製建構函式和過載賦值操作。類的複製建構函式原型如下：

class_name(const class_name &src);

一般來說，如果我們沒有編寫複製建構函式，那麼編譯器會自動地替每一個類建立一個複製建構函式（也叫隱式複製建構函式）；相反的，如果我們編寫了一個複製建構函式（顯式的複製建構函式），那麼編譯器就不會建立它。

類的過載賦值操作符的原型如下：

class_name& operator=(const class_name &);

過載賦值操作符是一個特別的賦值運算子，通常是用來把已存在的物件指定給其它相同型別的物件。它是一個特別的成員函式，如果我們沒有定義這個成員函式，那麼編譯器會自動地產生這個成員函式。編譯器產生的程式碼是以單一成員進行物件複製的動作。

總結了複製建構函式和過載賦值操作符的定義，只是讓我們瞭解了它們，而沒有真正的深入它們。接下來，再仔細的總結一下它們的呼叫時機。關於它們的呼叫時機，我一直都沒有真正的明白過，所以這裡一定要好好的總結明白了。

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

對複製建構函式和過載賦值操作符的呼叫總是發生在不經意間，它們不是經過我們顯式的去呼叫就被執行了。對於這種隱式呼叫的地方一定要多注意了，這也一般是有陷阱的地方。現在我就用實際的例子來進行驗證；例子如下：

#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;
}

在程式碼中都加入了註釋，這裡就不再做詳細的說明了。再次總結一下，如果物件在宣告的同時將另一個已存在的物件賦給它，就會呼叫複製建構函式；如果物件已經存在了，然後再將另一個已存在的物件賦給它，呼叫的就是過載賦值運算子了。這條規則很適用，希望大家能記住。

複製建構函式和過載賦值操作符的實現要點

在一般的情況下，編譯器給我們生成的預設的複製建構函式和過載賦值操作符就已經夠用了；但是在一些特別的時候，需要我們手動去實現自己的複製建構函式。

我們都知道，預設的複製建構函式和賦值運算子進行的都是”shallow copy”，只是簡單地複製欄位，因此如果物件中含有動態分配的記憶體，就需要我們自己重寫複製建構函式或者過載賦值運算子來實現”deep copy”，確保資料的完整性和安全性。這也就是大家常常說的深拷貝與淺拷貝的問題。下面我就提供一個比較簡單的例子來說明一下：

#include <iostream>
using namespace std;

const int MAXSIZE = 260;

class CTest
{
public:
     CTest(wchar_t *pInitValue)
     {
          // Here, I malloc the memory
          pValue = new wchar_t[MAXSIZE];
          memset(pValue, 0, sizeof(wchar_t) * MAXSIZE);
          wcscpy_s(pValue, MAXSIZE, pInitValue);
     }

     ~CTest()
     {
          if (pValue)
          {
               delete[] pValue; //finalseabiscuit指出，謝謝。2014.7.24
               pValue = NULL;
          }
     }

     CTest(const CTest &test)
     {
          // Malloc the new memory for the pValue
          pValue = new wchar_t[MAXSIZE];
          memset(pValue, 0, sizeof(wchar_t) * MAXSIZE);
          wcscpy_s(pValue, MAXSIZE, test.pValue);
     }

     CTest& operator=(const CTest &test)
     {
          // This is very important, please remember
          if (this == &test)
          {
               return *this;
          }

          // Please delete the memory, this maybe cause the memory leak
          if (pValue)
          {
               delete[] pValue; // 方恆剛指出的問題。非常感謝 2014.3.15
          }

          // Malloc the new memory for the pValue
          pValue = new wchar_t[MAXSIZE];
          memset(pValue, 0, sizeof(wchar_t) * MAXSIZE);
          wcscpy_s(pValue, MAXSIZE, test.pValue);
          return *this;
     }

     void Print()
     {
          wcout<<pValue<<endl;
     }

private:
     wchar_t *pValue; // The pointer points the memory
};

int main()
{
     CTest obj(L"obj");
     obj.Print();

     CTest obj2(L"obj2");
     obj2.Print();
     obj2 = obj;
     obj2.Print();

     obj2 = obj2;
     obj2.Print();

     return 0;
}

特別是在實現過載賦值建構函式時需要多多的注意，在程式碼中我也新增了註釋，大家可以認真的閱讀一下程式碼，然後就懂了，如果不懂的就可以留言問我；當然了，如果我哪裡理解錯了，也希望大家能給我提出，我們共同進步。

複製建構函式的一些細節

  1. 以下哪些是複製建構函式 
    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); //當然也是拷貝建構函式
  2. 類中可以存在超過一個拷貝建構函式 
    class X 
{ 
public:       
  X(const X&);      // const 的拷貝構造
  X(X&);            // 非const的拷貝構造
};
    注意，如果一個類中只存在一個引數為 X& 的拷貝建構函式，那麼就不能使用const X或volatile X的物件實行拷貝初始化。如果一個類中沒有定義拷貝建構函式,那麼編譯器會自動產生一個預設的拷貝建構函式。這個預設的引數可能為 X::X(const X&)或 X::X(X&),由編譯器根據上下文決定選擇哪一個。在我的Visual Studio 2012中，當定義了多個複製建構函式以後，編譯器就會有warning，但是程式還能正確執行。

總結

這篇文章對複製建構函式和過載賦值操作符進行了一些總結，重點是在複製建構函式與過載賦值操作符的呼叫時機上；對於大家喜歡總結的深拷貝與淺拷貝問題，我沒有用過多的文字進行說明，我認為上面的程式碼就足以說明問題了。最後自己糾結已久的問題也就這樣總結了，自己也徹底的明白了。

相關文章