【原創】漫談C++深淺拷貝

對於一般的對象，如：

int a = 10;
int b = 20;

它們之間的賦值、復制過程是很簡單的。但是對於類對象來說，其內部存在各種類型成員變量，在拷貝過程中會出現問題。如下：

#include<iostream>
#include<cstring>
using namespace std;
class String {
public:
    String (const char* psz=NULL) : m_psz(strcpy(new char[strlen(psz?psz:"")+1]),psz?psz:""){
        cout << "String構造" << endl;
    }
     ~String () {
        if(m_psz) {
             delete[] m_psz;
             m_psz = NULL;
        }
        cout << "String析構" << endl;
    }
    char* c_str(void) {
        return m_psz;
    }
private:
    char* m_psz;
};
int main(void) {
    String s1("hello");
    String s2(s1);
    cout << "s1    " << s1.c_str() << endl;
    cout << "s2    " << s2.c_str() << endl;
    s1.c_str()[0] = 'H';
    cout << "s1    " << s1.c_str() << endl;
    cout << "s2    " << s2.c_str() << endl;
    return 0;
}

./a.out

編譯通過了，運行后出現一堆的錯誤，為什么？！這就是淺拷貝帶來的問題。

事實是，在對象拷貝過程中，如果沒有自定義拷貝構造函數，系統會提供一個缺省的拷貝構造函數，缺省的拷貝構造函數對於基本類型的成員變量，按字節復制，對於類類型成員變量，調用其相應類型的拷貝構造函數。原型如下：

String (const String& that) {}

但凡是編譯系統提供的缺省函數，總不是十全十美的。

缺省拷貝構造函數在拷貝過程中是按字節復制的，對於指針型成員變量只復制指針本身，而不復制指針所指向的目標----淺拷貝。

用下圖來解釋這個問題：

在進行對象復制后，事實上s1,s2里的成員指針m_psz都指向了一塊內存空間（即內存空間共享了），在s1析構時，delete了成員指針m_psz所指向的內存空間，而s2析構時同樣指向（此時已變成野指針）並且要釋放這片已經被s1析構函數釋放的內存空間，這就讓同樣一片內存空間出現了“double free” ，從而出錯。而淺拷貝還存在着一個問題，因為一片空間被兩個不同的子對象共享了，只要其中的一個子對象改變了其中的值，那另一個對象的值也跟着改變了，正如程序中只改變了s1.c_str()[0] = 'H'，然而輸出的s1,s2均為
hello，所以這並不是真正意義上的復制。

為了實現深拷貝，往往需要自己定義拷貝構造函數，在源代碼里，我們加入自定義的拷貝構造函數如下：

String (const String& that) : m_psz(strcpy((new char[strlen(that.m_psz)+1]),that.m_psz)){
    cout << "String拷貝構造" << endl;
}

這樣再運行就沒有問題了。

在程序中，還有哪些情況會用到拷貝構造函數呢？當函數存在對象型的參數或對象型的返回值時都會用到拷貝構造函數。

而拷貝賦值的情況基本上與拷貝復制是一樣的。只是拷貝賦值是屬於操作符重載問題。例如在主函數若有：String s3;s3 = s2;這樣系統在執行時會調用系統提供的缺省的拷貝賦值函數，原型如下：

void operator = (const String& that) {}

 我們可以自定義拷貝賦值函數如下：

void operator=(const String& that) {
    m_psz = strcpy (new char[strlen(that.m_psz)+1],that.m_psz);
}

但是這只是新手級別的寫法，考慮的問題太少。我們知道對於普通變量來講a=b返回的是左值a的引用，所以它可以作為左值繼續接收其他值(a=b)=30,這樣來講我們操作符重載后返回的應該是類對象的引用（否則返回值將不能作為左值來進行運算），如下：

String& operator=(const String& that){
    m_psz = strcpy (new char[strlen(that.m_psz)+1],that.m_psz);
}

而 m_psz = strcpy (new char[strlen(that.m_psz)+1],that.m_psz);這種寫法其實也有問題，因為在執行語句時，m_psz已經被構造已經分配了內存空間，但是如此進行指針賦值，m_psz直接轉而指向另一片新new出來的內存空間，而丟棄了原來的內存，這樣便造成了內存泄露。應更改為：

 

String& operator=(const String& that) {
    delete[] m_psz;
    m_psz = strcpy (new char[strlen (that.m_psz)+1],that.m_psz);
}

 

這樣就行了嗎？在這個世界上不怕沒好事就怕沒好人，萬一他跟你搞一個自賦值（s3=s3）怎么辦？

 

 操作符左右兩邊都是同一個對象，這樣先delete[] m_psz，后面又有that.m_psz，這就出現了問題。所以為了防止自賦值，我們一般的寫法為：

String& operator=(cosnt String& that) {
    if(&that != this) {
        delete[] m_psz;
        m_psz = strcpy (new char[strlen(that.m_psz)+1],that.m_psz);   
    }
    return *this;
}

可是這樣寫就完善了嗎？是否要再仔細思索一下，還存在問題嗎？！其實我可以告訴你，這樣的寫法也頂多算個初級工程師的寫法。前面說過，為了保證內存不泄露，我們前面delete[] m_psz，然后我們在把new出來的空間給了m_psz，但是這樣的問題是，你有考慮過萬一new失敗了呢？！內存分配失敗，m_psz沒有指向新的內存空間，但是它卻已經把舊的空間給扔掉了，所以顯然這樣的寫法依舊存在着問題。一般高級工程師的寫法會是這樣的：

String& operator=(cosnt String& that) {
    if(&that != this) {
        char *psz = strcpy (new char[strlen(that.m_psz)+1],that.m_psz);//如果失敗會拋出異常，m_psz最后在析構函數里釋放
        delete[] m_psz;
        m_psz = psz;   
    }
    return *this;
}

這樣考慮的問題便比較全面了。

高級工程師高確實高，然而有沒有比高級工程師更高的工程師呢？答案是肯定的。對於從事多年C++開發元老級別資深的C++工程師來講，他們不會這么寫，因為有更好更簡便的寫法，如下：

String& operator=(const String& that) {
    if(&that != this) {
        String str (that);
        char *psz = m_psz;
        m_psz = str.m_psz;
        str.m_psz = psz;
    }
    return *this;
}

有人看出來這樣寫的玄機了嗎？？

事實上，這是借助了以上自定義的拷貝構造函數。定義了局部對象str，在拷貝構造中已經為str的成員指針分配了一塊內存，所以只需要將str.m_psz與this->m_psz交換指針即可，簡化了程序的設計，因為str是局部對象，離開作用域會調用析構函數釋放交換給str.m_psz的內存，避免了內存泄露。

大家在讀完這篇文章后，對於C++的代碼設計，是否有一定的感悟了呢？在我們進行C++的代碼設計的過程中，一定要多加思索，考慮問題要全面，精益求精，寫出來的代碼才經得住推敲！