C++中的賦值操作符重載和拷貝構造函數

1，關於賦值的疑問：

    1，什么時候需要重載賦值操作符？

    2，編譯器是否提供默認的賦值操作符？

   

2，關於賦值的疑問：

    1，編譯器為每個類默認重載了賦值操作符；

       1，意味着同類型的類對象可以相互賦值；

    2，默認的賦值操作符僅完成淺拷貝；

    3，當需要進行深拷貝時必須重載賦值操作符；

       1，和拷貝構造函數相同；

    4，賦值操作符與拷貝構造函數有相同的存在意義；

   

3，默認賦值操作符重載編程實驗：

    1，main.cpp 文件：

#include <iostream>
#include <string>

using namespace std;

class Test
{
    int* m_pointer;
public:
    Test()
    {
        m_pointer = NULL;
    }
    Test(int i)
    {
        m_pointer = new int(i);
    }
    Test(const Test& obj)
    {
        m_pointer = new int(*obj.m_pointer);
    }
    Test& operator = (const Test& obj)  
    {
        if( this != &obj )  // 避免自賦值；
        {
            delete m_pointer;
            m_pointer = new int(*obj.m_pointer);
        }
        
        return *this;
    }
    void print()
    {
        cout << "m_pointer = " << hex << m_pointer << endl;
    }
    ~Test()
    {
        delete m_pointer;
    }
};

int main()
{
    Test t1 = 1;
    Test t2;
    
    t2 = t1;  // 默認賦值操作符的淺拷貝使得兩個對象內部指針指向同一片空間；

    int i = 0;  // C 語言中允許這樣，所以 C++ 中也必須允許；
    i = i;

    t2 = t2;  // C++  中也要允許自賦值，但是沒有意義；
    
    t1.print();
    t2.print();
    
    return 0;
}

　2，輸出結果：

　　m_pointer = 0x9387008

　　m_pointer = 0x9387018

　3，賦值操作符重載注意事項：

　　1，賦值操作符返回值一定是引用，為了連續賦值；

　　2，參數類型一定是 const Type&；

       3，不能自賦值；

       4，返回當前對象；

 

4，關於賦值的疑問：

 

    1，如果要進行深拷貝，拷貝構造函數和賦值操作符的實現都要自定義；

   

5，一般性原則：

    1，重載賦值操作符，必然要實現深拷貝；

       1，實現深拷貝和自定義賦值操作符及拷貝構造函數是充要條件；

   

6，數組類的優化編程實驗：

    1，IntArray.h 文件：

#ifndef _INTARRAY_H_
#define _INTARRAY_H_

class IntArray
{
private:
    int m_length;
    int* m_pointer;
    
    IntArray(int len);
    IntArray(const IntArray& obj);
    bool construct();
public:
    static IntArray* NewInstance(int length); 
    int length();
    bool get(int index, int& value);
    bool set(int index ,int value);
    int& operator [] (int index);
    IntArray& operator = (const IntArray& obj);
    IntArray& self();
    ~IntArray();
};

    2，首先寫出賦值操作符注意事項模板：

IntArray& IntArray::operator = (cosnt IntArray& obj)
{
     if( this != &obj )
     {
         
     }

     return *this;
}

    3，函數實現：

IntArray& IntArray::operator = (const IntArray& obj)
{
    if( this != &obj )
    {
        int* pointer = new int[obj.m_length];
        
        if( pointer )
        {
        /* 復制參數對象中的元素 */
            for(int i=0; i<obj.m_length; i++)
            {
                pointer[i] = obj.m_pointer[i];
            }
            
        /* 深拷貝 */
            m_length = obj.m_length;
            delete[] m_pointer;
            m_pointer = pointer;
        }
    }
    
    return *this;
}

　4，main.cpp 文件：

#include <iostream>
#include <string>
#include "IntArray.h"

using namespace std;

int main()
{
    IntArray* a = IntArray::NewInstance(5);   
    IntArray* b = IntArray::NewInstance(10);
    
    if( a && b )
    {
        IntArray& array = a->self();
        IntArray& brray = b->self();
        
        cout << "array.length() = " << array.length() << endl;
        cout << "brray.length() = " << brray.length() << endl;
    
        array = brray;
        
        cout << "array.length() = " << array.length() << endl;
        cout << "brray.length() = " << brray.length() << endl;
    }
    
    delete a;
    delete b;
    
    return 0;
}

　5，輸出結果：

array.length() = 5

brray.length() = 10

array.length() = 10

brray.length() = 10 

    6，使用二階構造后，拷貝構造函數是私有的，拷貝構造函數就沒有作用了，不允許拷貝構造，但是應該重載賦值操作符重載；

   

7，編譯器默認提供函數：

 

    1，雖然類中什么都沒寫，但是編譯器會放四個函數實現進去；

   

8，下面的代碼輸出什么？為什么？

    1，代碼示例：

string s = "12345";
const char* p = s.c_str();  // 返回字符指針，代表 C 語言中的字符串；

cout << p << endl;

s.append("abced");

cout << p << endl;

   

9，字符串問題 1 編程實驗：

    1，main.cpp 文件：

#include <iostream>
#include <string>

using namespace std;

int main()
{
    string s = "12345";
    const char* p = s.c_str();  // 只有這一行用了 C 方式；
        
    cout << p << endl;     
        
    s.append("abced");  // p 成為了野指針
        
    cout << p << endl;     

    return 0;
}

　2，這段代碼混合了 C 和 C++ 的方式，出了意想不到的錯誤；

   

10，關於 string 的疑問 1：

    1，string 對象內部維護了一個指向數據的 char* 指針，這個指針可能在程序     運行的過程中發生改變，我們盡量不要操作這個指針；

    2，執行 s.append() 函數后，char* 指針指向了新的堆空間 0xFF445566，而將舊的堆空間 0xFF112233 釋放，此時 p 指針成了野指針；

    3，學習 C++，並且用的是標准庫中的內容，所以現在采用的編程思想就應該是 C++ 編程思想，不要混合使用 C 和 C++ 思想；

   

11，下面的程序輸出什么？為什么？

    1，代碼示例：

const char* p = "12345";  // p 可以用字符串對象代替；
string s = "";  // 混合了，該注意了；
        
s.reserve(10);
    
// 不要使用 C 語言中的方式操作 C++ 中的字符串
for(int i=0; i<5; i++)
{
       s[i] = p[i];
}

if( !s.empty() )
{
    cout << s << endl;
}

    2，沒有輸出；

   

12，字符串問題 2 編程實驗：

    1，main.cpp 文件：

#include <iostream>
#include <string>

using namespace std;

int main()
{
    const char* p = "12345";
    string s = "";
        
    s.reserve(10);
    
    // 不要使用 C 語言中的方式操作 C++ 中的字符串
    for(int i=0; i<5; i++)
    {
        s[i] = p[i];
    }

            if( !s.empty() )  // 打印不出；
        {
          cout << s << endl;
        }

    cout << s << endl;  // 打印不出；

    for(int i=0; i<5; i++)  // 可以打印；
    {
        cout << s[i] << endl;
    }
    
    return 0;
}

　2，更改程序為：

#include <iostream>
#include <string>

using namespace std;

int main()
{
    const string p = "12345";
    string s = "";

    s = p;

    cout << s << endl;
    
    return 0;
}

　3，C++ 工程中，盡量避免指針使用，字符串類出現就是為了替代字符指針；

 

13，關於 string 的疑問 2：

 

14，小結：

    1，在需要進行深拷貝的時候必須重載賦值操作符；

       1，也要重新定義拷貝構造函數；

    2，賦值操作符和拷貝構造函數有同等重要的意義；

    3，string 類通過一個數據空間保存字符串數據；

    4，string 類通過一個成員變量保存當前字符串的長度；

    5，C++ 開發時盡量避開 C 語言中慣用的編程思想；

       1，字符串類得到的是字符串對象，直接用成員函數操作這個對象就可以，不需要用 C 語言中的 for 循環之類的；