什么是復制和交換習語，什么時候應該使用它？它解決了什么問題？C 11 會改變嗎？

有關的：

• 您最喜歡的 C 編碼風格習語是什么：復制交換
• C 中的復制建構式和 = 運算子多載：是否可以使用通用函式？
• 什么是復制省略以及它如何優化復制和交換習語
• C ：動態分配物件陣列？

uj5u.com熱心網友回復：

概述

為什么我們需要復制和交換習語？

任何管理資源（包裝器，如智能指標）的類都需要實作三巨頭。雖然復制建構式和解構式的目標和實作很簡單，但復制賦值運算子可以說是最微妙和最困難的。應該怎么做？需要避免哪些陷阱？

復制和交換習慣用法是解決方案，它優雅地幫助賦值運算子實作兩件事：避免代碼重復，并提供強大的例外保證。

它是如何作業的？

從概念上講，它通過使用復制建構式的功能來創建資料的本地副本，然后使用swap函式獲取復制的資料，將舊資料與新資料交換。臨時副本然后破壞，帶走舊資料。我們留下了新資料的副本。

為了使用復制和交換習慣用法，我們需要三樣東西：一個有效的復制建構式，一個有效的解構式（兩者都是任何包裝器的基礎，所以無論如何都應該是完整的）和一個swap函式。

交換函式是一個非拋出函式，它交換一個類的兩個物件，一個成員一個成員。我們可能會想使用std::swap而不是提供我們自己的，但這是不可能的；std::swap在其實作中使用復制建構式和復制賦值運算子，我們最終將嘗試根據自身來定義賦值運算子！

（不僅如此，對 的非限定呼叫swap將使用我們的自定義交換運算子，跳過我們類的不必要的構造和破壞std::swap。）

深入的解釋

目標

讓我們考慮一個具體案例。我們想在一個無用的類中管理一個動態陣列。我們從一個作業建構式、復制建構式和解構式開始：

#include <algorithm> // std::copy
#include <cstddef> // std::size_t

class dumb_array
{
public:
    // (default) constructor
    dumb_array(std::size_t size = 0)
        : mSize(size),
          mArray(mSize ? new int[mSize]() : nullptr)
    {
    }

    // copy-constructor
    dumb_array(const dumb_array& other)
        : mSize(other.mSize),
          mArray(mSize ? new int[mSize] : nullptr)
    {
        // note that this is non-throwing, because of the data
        // types being used; more attention to detail with regards
        // to exceptions must be given in a more general case, however
        std::copy(other.mArray, other.mArray   mSize, mArray);
    }

    // destructor
    ~dumb_array()
    {
        delete [] mArray;
    }

private:
    std::size_t mSize;
    int* mArray;
};

這個類幾乎成功地管理了陣列，但它需要operator=正常作業。

一個失敗的解決方案

這是一個天真的實作可能看起來的樣子：

// the hard part
dumb_array& operator=(const dumb_array& other)
{
    if (this != &other) // (1)
    {
        // get rid of the old data...
        delete [] mArray; // (2)
        mArray = nullptr; // (2) *(see footnote for rationale)

        // ...and put in the new
        mSize = other.mSize; // (3)
        mArray = mSize ? new int[mSize] : nullptr; // (3)
        std::copy(other.mArray, other.mArray   mSize, mArray); // (3)
    }

    return *this;
}

我們說我們完成了；這現在管理一個陣列，沒有泄漏。但是，它存在三個問題，在代碼中依次標記為(n).

1. 首先是自我分配測驗。
   此檢查有兩個目的：它是防止我們在自賦值時運行不必要的代碼的簡單方法，它保護我們免受細微錯誤的影響（例如洗掉陣列只是為了嘗試復制它）。但在所有其他情況下，它只是用來減慢程式速度，并在代碼中充當噪音；自賦值很少發生，所以大多數時候這種檢查都是浪費。
   如果沒有它，操作員也能正常作業，那就更好了。

2. 二是它只提供基本的例外保證。如果new int[mSize]失敗，*this將被修改。（也就是說，大小不對，資料消失了！）
   為了獲得強大的例外保證，它需要類似于：

    dumb_array& operator=(const dumb_array& other)
    {
        if (this != &other) // (1)
        {
            // get the new data ready before we replace the old
            std::size_t newSize = other.mSize;
            int* newArray = newSize ? new int[newSize]() : nullptr; // (3)
            std::copy(other.mArray, other.mArray   newSize, newArray); // (3)
   
            // replace the old data (all are non-throwing)
            delete [] mArray;
            mSize = newSize;
            mArray = newArray;
        }
   
        return *this;
    }
   

3. 代碼擴展了！這就引出了第三個問題：代碼重復。

我們的賦值運算子有效地復制了我們已經在其他地方撰寫的所有代碼，這是一件很糟糕的事情。

在我們的例子中，它的核心只有兩行（分配和復制），但是對于更復雜的資源，這個代碼膨脹可能會很麻煩。我們應該努力不重復自己。

（有人可能想知道：如果正確管理一個資源需要這么多代碼，如果我的類管理多個資源怎么辦？
雖然這似乎是一個有效的問題，而且確實需要不平凡的try/catch子句，但這是一個非-問題。
那是因為一個類應該只管理一個資源！）

一個成功的解決方案

如前所述，復制和交換習慣用法將解決所有這些問題。但是現在，我們擁有所有要求，除了一個：swap函式。swap雖然三原則成功地包含了我們的復制建構式、賦值運算子和解構式的存在，但它實際上應該被稱為“三大半”：任何時候你的類管理一個資源，提供一個函式也是有意義的.

我們需要向我們的類添加交換功能，我們按如下方式進行?：

class dumb_array
{
public:
    // ...

    friend void swap(dumb_array& first, dumb_array& second) // nothrow
    {
        // enable ADL (not necessary in our case, but good practice)
        using std::swap;

        // by swapping the members of two objects,
        // the two objects are effectively swapped
        swap(first.mSize, second.mSize);
        swap(first.mArray, second.mArray);
    }

    // ...
};

（這里是原因的解釋public friend swap。）現在我們不僅可以交換我們dumb_array的 's，而且一般來說交換可以更有效率；它只是交換指標和大小，而不是分配和復制整個陣列。除了在功能和效率方面的這一優勢之外，我們現在已經準備好實施復制和交換習慣用法。

事不宜遲，我們的賦值運算子是：

dumb_array& operator=(dumb_array other) // (1)
{
    swap(*this, other); // (2)

    return *this;
}

就是這樣！一下子，三個問題一下子被優雅解決了。

為什么它有效？

我們首先注意到一個重要的選擇：引數引數是按值獲取的。雖然可以很容易地執行以下操作（實際上，該習語的許多天真實作都可以做到）：

dumb_array& operator=(const dumb_array& other)
{
    dumb_array temp(other);
    swap(*this, temp);

    return *this;
}

我們失去了一個重要的優化機會。不僅如此，這個選擇在 C 11 中很關鍵，稍后會討論。（總的來說，一個非常有用的指導方針如下：如果你要在函式中復制某些東西，讓編譯器在引數串列中完成它。?）

無論哪種方式，這種獲取資源的方法都是消除代碼重復的關鍵：我們可以使用復制建構式中的代碼來制作副本，而無需重復其中的任何一點。現在復制已經完成，我們準備交換。

請注意，在進入函式時，所有新資料都已分配、復制并準備好使用。這就是免費為我們提供強大例外保證的原因：如果副本構造失敗，我們甚至不會進入該函式，因此無法更改*this. （我們之前手動為強例外保證所做的事情，編譯器現在正在為我們做；真好。）

此時我們無家可歸，因為swap是非拋。我們用復制的資料交換當前資料，安全地改變我們的狀態，舊資料被放入臨時資料。當函式回傳時，舊資料將被釋放。（在引數范圍結束并呼叫其解構式的地方。）

因為習慣用法不重復代碼，所以我們不能在運算子中引入錯誤。請注意，這意味著我們不再需要自賦值檢查，允許operator=. （此外，我們不再對非自我分配進行性能懲罰。）

這就是復制和交換習語。

C 11 呢？

C 的下一個版本 C 11 對我們管理資源的方式做了一個非常重要的改變：三法則現在是四法則（半）。為什么？因為我們不僅需要能夠復制構建我們的資源，我們還需要移動構建它。

對我們來說幸運的是，這很容易：

class dumb_array
{
public:
    // ...

    // move constructor
    dumb_array(dumb_array&& other) noexcept ??
        : dumb_array() // initialize via default constructor, C  11 only
    {
        swap(*this, other);
    }

    // ...
};

這里發生了什么？回想一下移動構造的目標：從類的另一個實體中獲取資源，使其處于保證可分配和可破壞的狀態。

所以我們所做的很簡單：通過默認建構式（C 11 特性）進行初始化，然后用other;交換。我們知道我們類的默認構造實體可以安全地分配和銷毀，所以我們知道other在交換后將能夠做同樣的事情。

（請注意，某些編譯器不支持建構式委托；在這種情況下，我們必須手動默認構造類。這是一個不幸但幸運的是微不足道的任務。）

為什么這樣行得通？

這是我們需要對類進行的唯一更改，那么為什么它會起作用呢？請記住我們做出的讓引數成為一個值而不是參考的非常重要的決定：

dumb_array& operator=(dumb_array other); // (1)

Now, if other is being initialized with an rvalue, it will be move-constructed. Perfect. In the same way C 03 let us re-use our copy-constructor functionality by taking the argument by-value, C 11 will automatically pick the move-constructor when appropriate as well. (And, of course, as mentioned in previously linked article, the copying/moving of the value may simply be elided altogether.)

And so concludes the copy-and-swap idiom.

Footnotes

*Why do we set mArray to null? Because if any further code in the operator throws, the destructor of dumb_array might be called; and if that happens without setting it to null, we attempt to delete memory that's already been deleted! We avoid this by setting it to null, as deleting null is a no-operation.

?還有其他說法，我們應該專門std::swap針對我們的型別，提供一個類swap內和一個自由函式swap等。但這都是不必要的：任何正確使用都swap將通過不合格的呼叫，我們的功能將是通過ADL找到。一個功能就可以了。

?原因很簡單：一旦您擁有自己的資源，您就可以交換和/或移動它 (C 11) 到任何需要的地方。通過在引數串列中制作副本，您可以最大限度地優化。

??移動建構式通常應該是，否則即使移動有意義noexcept，一些代碼（例如調整大小邏輯）也會使用復制建構式。std::vector當然，只有在里面的代碼沒有拋出例外的情況下，才標記為noexcept。

uj5u.com熱心網友回復：

賦值的核心是兩個步驟：拆除物件的舊狀態，并將其新狀態構建為其他物件狀態的副本。

基本上，這就是解構式和復制建構式所做的，所以第一個想法是將作業委托給它們。然而，由于破壞不能失敗，而構造可能會失敗，我們實際上想以相反的方式進行：首先執行建設性部分，如果成功，然后進行破壞性部分。copy-and-swap 慣用語就是實作這一點的一種方法：它首先呼叫類的復制建構式來創建一個臨時物件，然后將其資料與臨時物件交換，然后讓臨時物件的解構式銷毀舊狀態。
自從swap()應該永遠不會失敗，唯一可能失敗的部分是復制構造。該操作首先執行，如果失敗，則目標物件中不會發生任何更改。

在其改進的形式中，復制和交換是通過初始化賦值運算子的（非參考）引數來執行復制來實作的：

T& operator=(T tmp)
{
    this->swap(tmp);
    return *this;
}

uj5u.com熱心網友回復：

已經有一些很好的答案。我將主要關注我認為他們缺乏的東西——用復制和交換成語解釋“缺點”……

什么是復制和交換成語？

一種根據交換函式實作賦值運算子的方法：

X& operator=(X rhs)
{
    swap(rhs);
    return *this;
}

基本思想是：

• 分配給物件最容易出錯的部分是確保獲取新狀態所需的任何資源（例如記憶體、描述符）

• 如果制作了新值的副本，則可以在修改物件的當前狀態（即）之前嘗試獲取，這就是為什么按值（即復制）而不是按參考接受*thisrhs

• 交換本地副本的狀態rhs并且*this通常相對容易做到而沒有潛在的故障/例外，因為本地副本之后不需要任何特定狀態（只需要適合解構式運行的狀態，就像移動物件一樣來自 >= C 11)

應該什么時候使用？（它解決了哪些問題[/create]？）

• 當您希望分配給物件不受拋出例外的分配的影響時，假設您已經或可以撰寫swap具有強例外保證的物件，并且理想情況下不會失敗/ throw..?

• 當您想要一種干凈、易于理解、健壯的方式來根據（更簡單的）復制構造swap函式和解構式定義賦值運算子時。

  • 作為復制和交換完成的自我分配避免了經常被忽視的邊緣情況。?

• 當分配期間有一個額外的臨時物件導致的任何性能損失或暫時更高的資源使用對您的應用程式不重要時。?

?swap拋出：通常可以可靠地交換物件通過指標跟蹤的資料成員，但是沒有無拋出交換的非指標資料成員，或者必須實作交換的非指標資料成員X tmp = lhs; lhs = rhs; rhs = tmp;和復制構造或賦值可能會拋出，仍然有可能失敗，導??致某些資料成員被交換而其他資料成員則沒有。這種潛力甚至適用于 C 03std::string詹姆斯對另一個答案的評論：

@wilhelmtell：在 C 03 中，沒有提及 std::string::swap（由 std::swap 呼叫）可能拋出的例外。在 C 0x 中，std::string::swap 是 noexcept 且不得拋出例外。——James McNellis 10 年 12 月 22 日 15:24

? 賦值運算子的實作在從一個不同的物件賦值時看起來很正常，但對于自賦值來說很容易失敗。雖然客戶端代碼甚至會嘗試自賦值似乎是不可想象的，但在容器上的演算法操作期間它可以相對容易地發生，其中x = f(x);代碼f（可能僅適用于某些#ifdef分支）是宏 ala#define f(x) x或回傳對 的參考的函式x，甚至（可能效率低下但簡潔）代碼，如x = c1 ? x * 2 : c2 ? x / 2 : x;)。例如：

struct X
{
    T* p_;
    size_t size_;
    X& operator=(const X& rhs)
    {
        delete[] p_;  // OUCH!
        p_ = new T[size_ = rhs.size_];
        std::copy(p_, rhs.p_, rhs.p_   rhs.size_);
    }
    ...
};

在自我分配時，上面的代碼 delete's x.p_;, 指向p_新分配的堆區域，然后嘗試讀取其中未初始化的資料（未定義行為），如果這沒有做任何太奇怪的事情，則copy嘗試對每個自我分配 -破壞'T'！

? copy-and-swap 習慣用法可能會由于使用額外的臨時變數而導致效率低下或限制（當運算子的引數是復制構造時）：

struct Client
{
    IP_Address ip_address_;
    int socket_;
    X(const X& rhs)
      : ip_address_(rhs.ip_address_), socket_(connect(rhs.ip_address_))
    { }
};

在這里，手寫Client::operator=可能會檢查是否*this已經連接到同一臺服務器rhs（如果有用，可能會發送“重置”代碼），而復制和交換方法將呼叫復制建構式，該建構式可能被撰寫為打開一個不同的套接字連接然后關閉原來的。這不僅意味著遠程網路互動而不是簡單的行程內變數副本，它還可能與客戶端或服務器對套接字資源或連接的限制發生沖突。（當然，這個類有一個非常糟糕的界面，但那是另一回事；-P）。

uj5u.com熱心網友回復：

這個答案更像是對上面答案的補充和輕微修改。

在某些版本的 Visual Studio（可能還有其他編譯器）中，存在一個非常煩人且沒有意義的錯誤。所以如果你swap像這樣宣告/定義你的函式：

friend void swap(A& first, A& second) {

    std::swap(first.size, second.size);
    std::swap(first.arr, second.arr);

}

...當您呼叫該swap函式時，編譯器會對您大喊大叫：

這與friend被呼叫的函式和this作為引數傳遞的物件有關。

解決這個問題的方法是不使用friend關鍵字并重新定義swap函式：

void swap(A& other) {

    std::swap(size, other.size);
    std::swap(arr, other.arr);

}

這一次，您可以呼叫swap并傳入other，從而使編譯器滿意：

畢竟，您不需要使用friend函式來交換 2 個物件。創建一個將一個物件作為引數swap的成員函式同樣有意義。other

您已經可以訪問this物件，因此將其作為引數傳遞在技術上是多余的。

uj5u.com熱心網友回復：

當您處理 C 11 風格的分配器感知容器時，我想補充一句警告。交換和賦值具有微妙不同的語意。

具體來說，讓我們考慮一個 container std::vector<T, A>，其中A是一些有狀態的分配器型別，我們將比較以下功能：

void fs(std::vector<T, A> & a, std::vector<T, A> & b)
{ 
    a.swap(b);
    b.clear(); // not important what you do with b
}

void fm(std::vector<T, A> & a, std::vector<T, A> & b)
{
    a = std::move(b);
}

這兩個函式的目的fs是fm給出最初a的狀態。b然而，有一個隱藏的問題：如果 會發生什么a.get_allocator() != b.get_allocator()？答案是：視情況而定。讓我們寫吧AT = std::allocator_traits<A>。

• 如果AT::propagate_on_container_move_assignment是std::true_type，則將的值fm重新分配給 的分配器，否則不分配，并繼續使用其原始分配器。在這種情況下，資料元素需要單獨交換，因為 和 的存盤不兼容。ab.get_allocator()aab

• 如果AT::propagate_on_container_swap是std::true_type，fs則以預期的方式交換資料和分配器。

• 如果AT::propagate_on_container_swap是std::false_type，那么我們需要動態檢查。

  • 如果a.get_allocator() == b.get_allocator()，則兩個容器使用兼容的存盤，并且交換以通常的方式進行。
  • 但是，如果a.get_allocator() != b.get_allocator()，程式有未定義的行為（參見 [container.requirements.general/8]。

結果是，一旦您的容器開始支持有狀態分配器，交換就成為 C 11 中的一項重要操作。這是一個有點“高級的用例”，但它并非完全不可能，因為移動優化通常只有在您的類管理資源時才會變得有趣，而記憶體是最受歡迎的資源之一。

標籤：C 拷贝构造函数赋值运算符C -常见问题解答复制和交换

上一篇：什么是三法則？

下一篇：無法獲取從基類派生的組件，泛型定義為Unity中的介面