C++ 賦值運算符'='的重載（淺拷貝、深拷貝）

01 賦值運算符重載的需求

有時候但願賦值運算符兩邊的類型能夠不匹配，好比：把一個 int 類型變量賦值給一個Complex（複數）對象，或把一個 char* 類型的字符串賦值給一個字符串對象，此時就須要重載賦值運算符‘=’。

須要注意的是：賦值運算符 = 只能重載爲成員函數。

---

02 賦值運算符重載的例子

下面咱們以自定義一個本身的字符串類代碼的例子，講解賦值運算符的重載函數。

class MyString // 字符串類
{
public:
    // 構造函數，默認初始化1個字節的字符
    MyString ():m_str(new char[1])
    {
        m_str[0] = 0;
    }
    
    // 析構函數，釋放資源
    ~MyString()
    {
        delete [] m_str;
    }
    
    const char* c_str()
    {
        return m_str;
    }
    
    // 賦值運算符重載函數
    // 重載=號使得 obj = "Hello" 可以成立
    MyString & operator= (const char *s)
    {
        // 釋放舊字符串資源
        delete [] m_str;
        
        // 生成新字符串的空間大小，長度多+1的目的是存放\0
        m_str = new char[strlen(s) +1 ];
        
        // 拷貝新字符串的內容
        strcpy(m_str, s);
        
        // 返回該對象
        return *this;
    }
    
private:
    char * m_str; // 字符串指針
};

int main() {
    
    MyString s;
    
    s = "Hello~"; // 等價於s.operator=("Hello~");
    std::cout << s.c_str()  << std::endl;
    
    // MyString s2 = "Hello!"; // 這條語句要是不註釋就會編譯報錯
    
    s = "Hi~"; // 等價於s.operator=("Hi~");
    std::cout << s.c_str()  << std::endl;

    return 0;
}

輸出結果：

Hello~
Hi~

重載=號運算符函數後，s = "Hello~"; 語句就等價於 s.operator=("Hello~");。

須要注意的一點是：上面的MyString s2 = "Hello!";語句其實是初始化語句，而不是賦值語句，由於是初始化語句，因此須要調用構造函數進行初始化，那麼這時就須要有char*參數的構造函數，因爲咱們沒有定義此構造函數，因此就會編譯出錯。

---

03 淺拷貝和深拷貝

仍是依據上面的例子，假設咱們要實現最後一個語句的方式：

MyString s1,s2;
s1 = "this"; // 調用重載的賦值語句
s2 = "that"; // 調用重載的賦值語句
s1 = s2; // 如何實現這個？？

s1 = s2;語句目的但願是s1對象放的字符串和s2對象放的字符串象要同樣，因爲 = 號兩邊的相似都是對象，編譯器會用原生的賦值運算符函數，可是這個原生的賦值運算符函數對於有指針成員變量的對象來講，是很是危險的！

淺拷貝

若是用原生的賦值運算符函數去賦值有指針成員變量的對象，就會使得兩個對象的指針地址也是同樣的，也就是兩個對象的指針成員變量指向的地址是同一個地方，這種方式就是淺拷貝。

這時當一個對象釋放了指針成員變量時，那麼另一個對象的指針成員變量指向的地址就是空的了，再次使用這個對象時，程序就會奔潰了，由於該對象的指針成員函數已是個不合法的指針了！

深拷貝

若是對象裏面有指針成員變量，則咱們須要對原生的賦值運算符函數，防止出現程序出錯現象的發生。

所以要在 class MyString 類里加上以下成員函數：

MyString & operator=(const MyString & s)
{
    // 釋放舊字符串資源
    delete [] m_str;
    
    // 生成新字符串的空間大小，長度多+1的目的是存放\0
    m_str = new char[strlen(s.m_str) +1 ];
    
    // 拷貝新字符串的內容
    strcpy(m_str, s.m_str);
    
    // 返回該對象
    return *this;
}

這麼作就夠了嗎？還有什麼須要改進的地方嗎？

咱們在考慮下面的語句：

MyString s;
s = "Hello";
s = s; // 是否會有問題？

最後一個語句是否會有問題？

s = s;等價於s.operator=(s)，因爲s和s是相同的對象，那麼就不必徹底執行重載的賦值 = 的函數了，咱們再加個判斷，當左右兩邊是相同對象時，就直接返回該對象就好：

MyString & operator=(const MyString & s)
{
    // 當左右兩邊是相同對象時，就直接返回該對象就
    if(this == &s)
        return *this;

    delete [] m_str;
    m_str = new char[strlen(s.m_str) +1 ];
    strcpy(m_str, s.m_str);
    return *this;
}

---

對operator=返回值類型的討論

• void 好很差？
• MyString 好很差？
• 爲何是MyString &？

當咱們重載一個運算符的時候，好的風格應該是儘可能保留運算符本來的特性

考慮：

• a = b = c; 這個賦值語句的順序是先b = c，而後在a = (b = c)。若是返回的void類型，那麼a = (void)顯然是不成立的；
• (a = b) = c; 這個賦值語句會修改a的值，若是返回的類型是MyString對象，那麼就沒法修改a的值了。

分別等價於：

• a.operator=(b.operator=(c));
• (a.operator=(b)).operator=(c);

因此綜上考慮，operator=返回值類型是MyString &是比較好的。

04 複製（拷貝）構造函數

上面的MyString類是否就沒有問題了？

MyString s;
s = "Hello";
MyString s1(s); // 要考慮這種狀況，那就要重載複製（拷貝）構造函數

若是使用默認的複製（拷貝）構造函數，那就對有指針成員變量的對象會有問題，由於會默認的複製（拷貝）構造函數會致使兩個對象的指針成員變量指向同一個的空間。

因此須要對複製（拷貝）構造函數重載，並實現深拷貝的方式：

MyString (const MyString &s)
{
    m_str = new char[strlen(s.m_str) + 1];
    strcpy(m_str, s.m_str);
}

05 小結

最後的全部代碼，以下：

class MyString // 字符串類
{
public:
    // 構造函數，默認初始化1個字節的字符
    MyString ():m_str(new char[1])
    {
        m_str[0] = 0;
    }
    
    // 複製（拷貝）構造函數
    MyString (const MyString &s)
    {
        m_str = new char[strlen(s.m_str) + 1];
        strcpy(m_str, s.m_str);
    }
    
    // 析構函數，釋放資源
    ~MyString()
    {
        delete [] m_str;
    }
    
    const char* c_str()
    {
        return m_str;
    }
    
    // 賦值運算符重載函數
    // 重載=號使得 obj = "Hello" 可以成立
    MyString & operator= (const char *s)
    {
        // 釋放舊字符串資源
        delete [] m_str;
        
        // 生成新字符串的空間大小，長度多+1的目的是存放\0
        m_str = new char[strlen(s) +1 ];
        
        // 拷貝新字符串的內容
        strcpy(m_str, s);
        
        // 返回該對象
        return *this;
    }
    
    // 賦值運算符重載函數
    // 重載=號使得 obj1 = obj2 可以成立
    MyString & operator=(const MyString & s)
    {
        // 當左右兩邊是相同對象時，就直接返回該對象就
        if(this == &s)
            return *this;
    
        delete [] m_str;
        m_str = new char[strlen(s.m_str) +1 ];
        strcpy(m_str, s.m_str);
        return *this;
    }
    
private:
    char * m_str; // 字符串指針
};

int main() 
{
    
    MyString s1,s2;
    
    s1 = "Hello~"; // 等價於s1.operator=("Hello~");
    std::cout << s1.c_str()  << std::endl;
    
    
    s2 = "Hi~"; // 等價於s2.operator=("Hi~");
    std::cout << s2.c_str()  << std::endl;
    
    s1 = s2;   // 等價於s1.operator=(s2);
    std::cout << s1.c_str()  << std::endl;
    
    MyString s3(s1);  // 複製構造函數
    std::cout << s3.c_str()  << std::endl;

    return 0;
}

輸出以下：

Hello~
Hi~
Hi~
Hi~