• 復制物件是什么意思？
• 什么是復制建構式和復制賦值運算子？
• 我什么時候需要自己申報？
• 如何防止我的物件被復制？

uj5u.com熱心網友回復：

介紹

C 使用值語意來處理用戶定義型別的變數。這意味著物件在各種背景關系中被隱式復制，我們應該理解“復制物件”的實際含義。

讓我們考慮一個簡單的例子：

class person
{
    std::string name;
    int age;

public:

    person(const std::string& name, int age) : name(name), age(age)
    {
    }
};

int main()
{
    person a("Bjarne Stroustrup", 60);
    person b(a);   // What happens here?
    b = a;         // And here?
}

（如果您name(name), age(age)對這部分感到困惑，這稱為成員初始化串列。）

特殊成員函式

復制物件是什么意思person？該main函式顯示了兩種不同的復制方案。初始化person b(a);由復制建構式執行。它的作業是根據現有物件的狀態構造一個新物件。賦值b = a由復制賦值運算子執行。它的作業通常稍微復雜一些，因為目標物件已經處于某種需要處理的有效狀態。

因為我們自己既沒有宣告復制建構式也沒有宣告賦值運算子（也沒有解構式），所以這些都是為我們隱式定義的。參考自標準：

[...] 復制建構式和復制賦值運算子、[...] 和解構式是特殊成員函式。[注意：當程式沒有顯式宣告它們時，實作將隱式宣告某些型別別的這些成員函式。 如果使用它們，實作將隱式定義它們。[...]尾注] [n3126.pdf 第 12 節 §1]

默認情況下，復制物件意味著復制其成員：

非聯合類 X 的隱式定義的復制建構式執行其子物件的成員復制。[n3126.pdf 第 12.8 節 §16]

非聯合類 X 的隱式定義的復制賦值運算子執行其子物件的成員復制賦值。[n3126.pdf 第 12.8 節 §30]

隱式定義

隱式定義的特殊成員函式person如下所示：

// 1. copy constructor
person(const person& that) : name(that.name), age(that.age)
{
}

// 2. copy assignment operator
person& operator=(const person& that)
{
    name = that.name;
    age = that.age;
    return *this;
}

// 3. destructor
~person()
{
}

在這種情況下，成員復制正是我們想要的： name和age被復制，所以我們得到一個自包含的、獨立的person物件。隱式定義的解構式始終為空。在這種情況下這也很好，因為我們沒有在建構式中獲取任何資源。成員的解構式在person解構式完成后隱式呼叫：

在執行解構式的主體并銷毀主體內分配的任何自動物件后，X 類的解構式呼叫 X 的直接 [...] 成員的解構式 [n3126.pdf 12.4 §6]

管理資源

那么我們什么時候應該顯式宣告那些特殊的成員函式呢？當我們的類管理一個資源的時候，也就是這個類的一個物件負責那個資源的時候。這通常意味著資源在建構式中獲取（或傳遞到建構式中）并在解構式中釋放。

讓我們回到準標準 C 的時代。沒有這樣的東西std::string，程式員都愛上了指標。該類person可能看起來像這樣：

class person
{
    char* name;
    int age;

public:

    // the constructor acquires a resource:
    // in this case, dynamic memory obtained via new[]
    person(const char* the_name, int the_age)
    {
        name = new char[strlen(the_name)   1];
        strcpy(name, the_name);
        age = the_age;
    }

    // the destructor must release this resource via delete[]
    ~person()
    {
        delete[] name;
    }
};

即使在今天，人們仍然以這種方式撰寫類并陷入困境：“我將一個人推入一個向量中，現在我出現了瘋狂的記憶體錯誤！ ”請記住，默認情況下，復制物件意味著復制其成員，但name僅復制成員復制一個指標，而不是它指向的字符陣列！這有幾個不愉快的影響：

1. 通過a可以觀察到變化b。
2. 一旦b被銷毀，a.name就是一個懸空指標。
3. 如果a被銷毀，洗掉懸掛指標會產生未定義的行為。
4. 由于賦值沒有考慮name賦值之前指向的內容，遲早你會到處都是記憶體泄漏。

顯式定義

由于按成員復制沒有達到預期的效果，我們必須顯式定義復制建構式和復制賦值運算子來制作字符陣列的深度復制：

// 1. copy constructor
person(const person& that)
{
    name = new char[strlen(that.name)   1];
    strcpy(name, that.name);
    age = that.age;
}

// 2. copy assignment operator
person& operator=(const person& that)
{
    if (this != &that)
    {
        delete[] name;
        // This is a dangerous point in the flow of execution!
        // We have temporarily invalidated the class invariants,
        // and the next statement might throw an exception,
        // leaving the object in an invalid state :(
        name = new char[strlen(that.name)   1];
        strcpy(name, that.name);
        age = that.age;
    }
    return *this;
}

請注意初始化和賦值之間的區別：我們必須在賦值之前拆除舊狀態name以防止記憶體泄漏。此外，我們必須防止 form 的自賦值x = x。如果沒有該檢查，delete[] name將洗掉包含源字串的陣列，因為當您撰寫 時x = x，this->name和that.name都包含相同的指標。

例外安全

new char[...]不幸的是，如果由于記憶體耗盡而拋出例外，此解決方案將失敗。一種可能的解決方案是引入區域變數并對陳述句重新排序：

// 2. copy assignment operator
person& operator=(const person& that)
{
    char* local_name = new char[strlen(that.name)   1];
    // If the above statement throws,
    // the object is still in the same state as before.
    // None of the following statements will throw an exception :)
    strcpy(local_name, that.name);
    delete[] name;
    name = local_name;
    age = that.age;
    return *this;
}

這也可以在沒有明確檢查的情況下處理自分配。這個問題的一個更強大的解決方案是copy-and-swap idiom，但我不會在這里深入討論例外安全的細節。我只提到例外來說明以下幾點：撰寫管理資源的類很困難。

不可復制的資源

有些資源不能或不應復制，例如檔案句柄或互斥體。在這種情況下，只需將復制建構式和復制賦值運算子宣告為 asprivate而無需給出定義：

private:

    person(const person& that);
    person& operator=(const person& that);

或者，您可以繼承boost::noncopyable或將它們宣告為已洗掉（在 C 11 及更高版本中）：

person(const person& that) = delete;
person& operator=(const person& that) = delete;

三個規則

有時您需要實作一個管理資源的類。（永遠不要在一個類中管理多個資源，這只會導致痛苦。）在那種情況下，請記住三個規則：

如果您需要自己顯式宣告解構式、復制建構式或復制賦值運算子，您可能需要顯式宣告所有這三個。

（不幸的是，這個“規則”并沒有被 C 標準或我所知道的任何編譯器強制執行。）

五法則

從 C 11 開始，一個物件有 2 個額外的特殊成員函式：移動建構式和移動賦值。治國五州也同樣履行這些職能。

帶有簽名的示例：

class person
{
    std::string name;
    int age;

public:
    person(const std::string& name, int age);        // Ctor
    person(const person &) = default;                // 1/5: Copy Ctor
    person(person &&) noexcept = default;            // 4/5: Move Ctor
    person& operator=(const person &) = default;     // 2/5: Copy Assignment
    person& operator=(person &&) noexcept = default; // 5/5: Move Assignment
    ~person() noexcept = default;                    // 3/5: Dtor
};

零規則

3/5 規則也稱為 0/3/5 規則。規則的零部分宣告您在創建類時可以不撰寫任何特殊成員函式。

建議

大多數時候，您不需要自己管理資源，因為現有的類std::string已經為您完成了。只需將使用std::string成員的簡單代碼與使用 a 的復雜且容易出錯的替代方法進行比較char*，您就會信服。只要您遠離原始指標成員，三規則就不太可能影響您自己的代碼。

uj5u.com熱心網友回復：

三法則是 C 的經驗法則，基本上是說

如果你的班級需要任何

• 一個復制建構式，
• 一個賦值運算子，
• 或解構式，

明確定義，那么很可能需要這三個。

這樣做的原因是它們三個通常都用于管理資源，如果您的類管理資源，它通常需要管理復制和釋放。

如果復制類管理的資源沒有良好的語意，則考慮通過宣告（不定義）復制建構式和賦值運算子來禁止復制private。

（請注意，即將發布的 C 標準新版本（即 C 11）向 C 添加了移動語意，這可能會改變三規則。但是，我對此知之甚少，無法撰寫 C 11 部分關于三法則。）

uj5u.com熱心網友回復：

三巨頭的法律如上所述。

一個簡單的例子，用簡單的英語，說明它解決的問題型別：

非默認解構式

您在建構式中分配了記憶體，因此您需要撰寫一個解構式來洗掉它。否則會導致記憶體泄漏。

您可能認為這已經完成了。

問題是，如果對您的物件進行了復制，那么該副本將指向與原始物件相同的記憶體。

有一次，其中一個在其解構式中洗掉了記憶體，另一個將有一個指向無效記憶體的指標（這稱為懸掛指標），當它試圖使用它時，事情會變得很麻煩。

因此，您撰寫了一個復制建構式，以便它為新物件分配自己的記憶體片段以銷毀。

賦值運算子和復制建構式

您在建構式中將記憶體分配給了類的成員指標。當您復制此類的物件時，默認賦值運算子和復制建構式會將此成員指標的值復制到新物件。

這意味著新物件和舊物件將指向同一塊記憶體，因此當您在一個物件中更改它時，另一個物件也會更改它。如果一個物件洗掉了這個記憶體，另一個將繼續嘗試使用它 - 哎呀。

為了解決這個問題，您撰寫了自己版本的復制建構式和賦值運算子。您的版本為新物件分配單獨的記憶體，并復制第一個指標指向的值而不是其地址。

uj5u.com熱心網友回復：

基本上如果你有一個解構式（不是默認的解構式），這意味著你定義的類有一些記憶體分配。假設該類由某些客戶端代碼或您在外部使用。

    MyClass x(a, b);
    MyClass y(c, d);
    x = y; // This is a shallow copy if assignment operator is not provided

如果 MyClass 只有一些原始型別成員，則默認賦值運算子可以作業，但如果它有一些指標成員和沒有賦值運算子的物件，則結果將不可預測。因此我們可以說，如果類的解構式中有要洗掉的東西，我們可能需要一個深復制運算子，這意味著我們應該提供一個復制建構式和賦值運算子。

uj5u.com熱心網友回復：

復制物件是什么意思？有幾種方法可以復制物件——讓我們談談您最有可能提到的兩種——深拷貝和淺拷貝。

由于我們使用的是面向物件的語言（或者至少假設是這樣），假設您分配了一塊記憶體。由于它是一種 OO 語言，我們可以輕松地參考我們分配的記憶體塊，因為它們通常是原始變數（整數、字符、位元組）或我們定義的由我們自己的型別和原始型別組成的類。假設我們有一個 Car 類，如下所示：

class Car //A very simple class just to demonstrate what these definitions mean.
//It's pseudocode C  /Javaish, I assume strings do not need to be allocated.
{
private String sPrintColor;
private String sModel;
private String sMake;

public changePaint(String newColor)
{
   this.sPrintColor = newColor;
}

public Car(String model, String make, String color) //Constructor
{
   this.sPrintColor = color;
   this.sModel = model;
   this.sMake = make;
}

public ~Car() //Destructor
{
//Because we did not create any custom types, we aren't adding more code.
//Anytime your object goes out of scope / program collects garbage / etc. this guy gets called   all other related destructors.
//Since we did not use anything but strings, we have nothing additional to handle.
//The assumption is being made that the 3 strings will be handled by string's destructor and that it is being called automatically--if this were not the case you would need to do it here.
}

public Car(const Car &other) // Copy Constructor
{
   this.sPrintColor = other.sPrintColor;
   this.sModel = other.sModel;
   this.sMake = other.sMake;
}
public Car &operator =(const Car &other) // Assignment Operator
{
   if(this != &other)
   {
      this.sPrintColor = other.sPrintColor;
      this.sModel = other.sModel;
      this.sMake = other.sMake;
   }
   return *this;
}

}

深拷貝是如果我們宣告一個物件，然后創建一個完全獨立的物件副本……我們最終會在 2 個完整的記憶體集中得到 2 個物件。

Car car1 = new Car("mustang", "ford", "red");
Car car2 = car1; //Call the copy constructor
car2.changePaint("green");
//car2 is now green but car1 is still red.

現在讓我們做一些奇怪的事情。假設 car2 要么編程錯誤，要么故意共享 car1 的實際記憶體。（這樣做通常是錯誤的，在課堂上通常是討論它的毯子。）假裝每當你詢問 car2 時，你實際上是在決議指向 car1 的記憶體空間的指標......這或多或少是一個淺拷貝是。

//Shallow copy example
//Assume we're in C   because it's standard behavior is to shallow copy objects if you do not have a constructor written for an operation.
//Now let's assume I do not have any code for the assignment or copy operations like I do above...with those now gone, C   will use the default.

 Car car1 = new Car("ford", "mustang", "red"); 
 Car car2 = car1; 
 car2.changePaint("green");//car1 is also now green 
 delete car2;/*I get rid of my car which is also really your car...I told C   to resolve 
 the address of where car2 exists and delete the memory...which is also
 the memory associated with your car.*/
 car1.changePaint("red");/*program will likely crash because this area is
 no longer allocated to the program.*/

因此，無論您使用何種語言撰寫，在復制物件時都要非常小心您的意思，因為大多數時候您需要深拷貝。

什么是復制建構式和復制賦值運算子？我已經在上面使用過它們。當您鍵入代碼時呼叫復制建構式，例如Car car2 = car1; Essentially 如果您宣告一個變數并在一行中分配它，那就是呼叫復制建構式的時候。賦值運算子是當您使用等號時發生的事情 -- car2 = car1;。通知car2未在同一宣告中宣告。您為這些操作撰寫的兩段代碼可能非常相似。事實上，典型的設計模式有另一個函式，一旦您確信初始復制/分配是合法的，您就可以呼叫它來設定所有內容——如果您看一下我寫的手寫代碼，這些函式幾乎是相同的。

我什么時候需要自己申報？如果您撰寫的代碼不是要共享或以某種方式用于生產，那么您實際上只需要在需要時宣告它們。如果您“偶然”選擇使用它并且沒有制作它，那么您確實需要了解您的程式語言的作用 - 即您獲得編譯器默認值。例如，我很少使用復制建構式，但賦值運算子覆寫很常見。您知道您也可以覆寫加法、減法等的含義嗎？

如何防止我的物件被復制？使用私有函式覆寫允許為物件分配記憶體的所有方式是一個合理的開始。如果你真的不希望人們復制它們，你可以將其公開并通過拋出例外而不是復制物件來提醒程式員。

uj5u.com熱心網友回復：

我什么時候需要自己申報？

三法則規定，如果你宣告任何一個

1. 復制建構式
2. 復制賦值運算子
3. 解構式

那么你應該宣告所有三個。它源于這樣的觀察，即需要接管復制操作的含義幾乎總是源于執行某種資源管理的類，并且幾乎總是暗示

• 在一個復制操作中完成的任何資源管理可能需要在另一個復制操作中完成，并且

• 類解構式也將參與資源管理（通常是釋放它）。要管理的經典資源是記憶體，這就是為什么所有管理記憶體的標準庫類（例如，執行動態記憶體管理的 STL 容器）都宣告“三巨頭”：復制操作和解構式。

三規則的結果是用戶宣告的解構式的存在表明簡單的成員智能復制不太可能適合類中的復制操作。反過來，這表明如果一個類宣告了一個解構式，復制操作可能不應該自動生成，因為它們不會做正確的事情。在采用 C 98 時，這一推理的意義并未得到充分認識，因此在 C 98 中，用戶宣告的解構式的存在對編譯器生成復制操作的意愿沒有影響。在 C 11 中仍然如此，但這只是因為限制生成復制操作的條件會破壞太多遺留代碼。

如何防止我的物件被復制？

將復制建構式和復制賦值運算子宣告為私有訪問說明符。

class MemoryBlock
{
public:

//code here

private:
MemoryBlock(const MemoryBlock& other)
{
   cout<<"copy constructor"<<endl;
}

// Copy assignment operator.
MemoryBlock& operator=(const MemoryBlock& other)
{
 return *this;
}
};

int main()
{
   MemoryBlock a;
   MemoryBlock b(a);
}

從 C 11 開始，您還可以宣告復制建構式和賦值運算子已洗掉

class MemoryBlock
{
public:
MemoryBlock(const MemoryBlock& other) = delete

// Copy assignment operator.
MemoryBlock& operator=(const MemoryBlock& other) =delete
};


int main()
{
   MemoryBlock a;
   MemoryBlock b(a);
}

uj5u.com熱心網友回復：

許多現有答案已經涉及復制建構式、賦值運算子和解構式。然而，在后 C 11 中，移動語意的引入可能會將其擴展到 3 以上。

最近 Michael Claisse 做了一個涉及這個話題的演講： http ://channel9.msdn.com/events/CPP/C-PP-Con-2014/The-Canonical-Class

uj5u.com熱心網友回復：

C 中的三原則是設計和開發三個要求的一個基本原則，如果在下面的一個成員函式中有明確的定義，那么程式員應該一起定義另外兩個成員函式。即以下三個成員函式缺一不可：解構式、拷貝建構式、拷貝賦值運算子。

C 中的拷貝建構式是一種特殊的建構式。它用于構建新物件，新物件相當于現有物件的副本。

復制賦值運算子是一種特殊的賦值運算子，通常用于將一個現有物件指定給其他相同型別的物件。

有一些簡單的例子：

// default constructor
My_Class a;

// copy constructor
My_Class b(a);

// copy constructor
My_Class c = a;

// copy assignment operator
b = a;

標籤：C 拷贝构造函数赋值运算符C -常见问题解答三法则

上一篇：運算子多載的基本規則和習慣用法是什么？

下一篇：什么是復制和交換成語？