含有指針成員的類的拷貝

本文轉自：http://zhedahht.blog.163.com/blog/static/25411174200722710364233/

題目：下面是一個數組類的聲明與實現。請分析這個類有什麼問題，並針對存在的問題提出幾種解決方案。

template<typename T> class Array
{
public:
      Array(unsigned arraySize):data(0), size(arraySize)
      {
            if(size > 0)
                  data = new T[size];
      }

      ~Array()
      {
            if(data) delete[] data;
      }

      void setValue(unsigned index, const T& value)
      {
            if(index < size)
                  data[index] = value;
      }

      T getValue(unsigned index) const
      {
            if(index < size)
                  return data[index];
            else
                  return T();
      }

private:
      T* data;
      unsigned size;
};

分析：我們注意在類的內部封裝了用來存儲數組數據的指針。軟件存在的大部分問題通常都可以歸結指針的不正確處理。

這個類只提供了一個構造函數，而沒有定義構造拷貝函數和重載拷貝運算符函數。當這個類的用戶按照下面的方式聲明並實例化該類的一個實例

Array A(10);
Array B(A);

或者按照下面的方式把該類的一個實例賦值給另外一個實例

Array A(10);
Array B(10);
B=A;

編譯器將調用其自動生成的構造拷貝函數或者拷貝運算符的重載函數。在編譯器生成的缺省的構造拷貝函數和拷貝運算符的重載函數，對指針實行的是按位拷貝，僅僅只是拷貝指針的地址，而不會拷貝指針的內容。因此在執行完前面的代碼之後，A.data和B.data指向的同一地址。當A或者B中任意一個結束其生命週期調用析構函數時，會刪除data。由於他們的data指向的是同一個地方，兩個實例的data都被刪除了。但另外一個實例並不知道它的data已經被刪除了，當企圖再次用它的data的時候，程序就會不可避免地崩潰。

由於問題出現的根源是調用了編譯器生成的缺省構造拷貝函數和拷貝運算符的重載函數。一個最簡單的辦法就是禁止使用這兩個函數。於是我們可以把這兩個函數聲明爲私有函數，如果類的用戶企圖調用這兩個函數，將不能通過編譯。實現的代碼如下：

private:
      Array(const Array& copy);
      const Array& operator = (const Array& copy);

最初的代碼存在問題是因爲不同實例的data指向的同一地址，刪除一個實例的data會把另外一個實例的data也同時刪除。因此我們還可以讓構造拷貝函數或者拷貝運算符的重載函數拷貝的不只是地址，而是數據。由於我們重新存儲了一份數據，這樣一個實例刪除的時候，對另外一個實例沒有影響。這種思路我們稱之爲深度拷貝。實現的代碼如下：

public:
      Array(const Array& copy):data(0), size(copy.size)
      {
            if(size > 0)
            {
                  data = new T[size];
                  for(int i = 0; i < size; ++ i)
                        setValue(i, copy.getValue(i));
            }
      }

      const Array& operator = (const Array& copy)
      {
            if(this == ©)
                  return *this;

            if(data != NULL)
            {
                  delete []data;
                  data = NULL;
            }

            size = copy.size;
            if(size > 0)
            {
                  data = new T[size];
                  for(int i = 0; i < size; ++ i)
                        setValue(i, copy.getValue(i));
            }
      }

爲了防止有多個指針指向的數據被多次刪除，我們還可以保存究竟有多少個指針指向該數據。只有當沒有任何指針指向該數據的時候纔可以被刪除。這種思路通常被稱之爲引用計數技術。在構造函數中，引用計數初始化爲1；每當把這個實例賦值給其他實例或者以參數傳給其他實例的構造拷貝函數的時候，引用計數加1，因爲這意味着又多了一個實例指向它的data；每次需要調用析構函數或者需要把data賦值爲其他數據的時候，引用計數要減1，因爲這意味着指向它的data的指針少了一個。當引用計數減少到0的時候，data已經沒有任何實例指向它了，這個時候就可以安全地刪除。實現的代碼如下：

public:
      Array(unsigned arraySize)
            :data(0), size(arraySize), count(new unsigned int)
      {
            *count = 1;
            if(size > 0)
                  data = new T[size];
      }

      Array(const Array& copy)
            : size(copy.size), data(copy.data), count(copy.count)
      {
            ++ (*count);
      }

      ~Array()
      {
            Release();
      }

      const Array& operator = (const Array& copy)
      {
            if(data == copy.data)
                  return *this;

            Release();

            data = copy.data;
            size = copy.size;
            count = copy.count;
            ++(*count);
      }

 private:
      void Release()
      {
            --(*count);
            if(*count == 0)
            {
                  if(data)
                  {
                        delete []data;
                        data = NULL;
                  }

                  delete count;
                  count = 0;
            }
      }

      unsigned int *count; 

結論：在包含有指針成員的類中，應該實現拷貝構造函數和重載賦值運算符（=）函數，以實現深度拷貝，以免調用系統生成的默認的拷貝構造函數和賦值=運算符函數（這兩個函數會進行淺拷貝）。

對於重載賦值元算符函數 operator=函數來說要注意四點，上一篇討論String的時候就已經詳細討論過，這裏再次總結如下：

1、應該返回類型的引用，以便連續賦值。

2、參數應該爲常應用，避免拷貝，並且因爲不會改變參數的值，顧採用常引用。

3、在程序起始時應該判斷this與參數的地址是否相同，如果是自己拷貝自己，則直接返回（比如參數爲parameter，則要判斷if(this == &parameter) return;）。

4、因爲是實現深度拷貝，所以如果指針成員不爲空，即已經指向了數據。那麼要先釋放指針成員指向的空間，避免內存泄露，然後再重新分配空間，並將保存在參數中的數據拷貝到重新分配的空間中。