什么是复制和交换习语？

Question

什么是复制和交换习惯用法以及何时应该使用它？它解决什么问题？ C++11 会改变吗？

相关：

• 您最喜欢的 C++ 编码风格习惯是什么： -swap
• C++ 中的复制构造函数和 = 运算符重载：可能是常见函数吗？
• 什么是复制省略以及它如何优化复制和交换习惯
• C++：动态分配对象数组？

Answer 1

概述

为什么我们需要复制和交换习惯用法？

任何管理资源的类（包装器，如智能指针）都需要实现三巨头。虽然复制构造函数和析构函数的目标和实现很简单，但复制赋值运算符可以说是最微妙和最困难的。应该怎么做呢？需要避免哪些陷阱？

复制和交换惯用语是解决方案，它优雅地帮助赋值运算符实现两件事：避免代码重复，并提供强大的异常保证。

它是如何运作的？

从概念上讲，它通过使用复制构造函数来工作创建数据的本地副本的功能，然后使用 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&运算符=（常量dumb_array＆amp;其他）
    {
        if (这个!= &other) // (1)
        {
            // 在替换旧数据之前准备好新数据
            std::size_t newSize = other.mSize;
            int* newArray = newSize ? new int[newSize]() : nullptr; // (3)
            std::copy(other.mArray, other.mArray + newSize, newArray); // (3)
   
            // 替换旧数据（都是不抛的）
            删除[] mArray；
            mSize = 新大小；
            mArray = newArray;
        }
   
        返回*这个；
    }
   

3. 代码已扩展！这就引出了第三个问题：代码重复。

我们的赋值运算符实际上复制了我们已经在其他地方编写的所有代码，这是一件可怕的事情。

在我们的例子中，它的核心只有两行（分配和复制），但是对于更复杂的资源，这种代码膨胀可能会很麻烦。我们应该努力不重复自己。

（有人可能会想：如果需要这么多代码来正确管理一种资源，那么如果我的类管理多个资源怎么办？
虽然这似乎是一个合理的担忧，并且确实需要不平凡的 try/catch 子句，但这不是问题。
这是因为类应该管理仅管理一个资源！）

一个成功的解决方案

如前所述，复制和交换习惯将解决所有这些问题。但现在，我们已经满足了所有要求，除了一个：交换函数。虽然“三法则”成功地保证了复制构造函数、赋值运算符和析构函数的存在，但它实际上应该被称为“三大半”：任何时候您的类管理资源时，提供 <代码>交换功能。

我们需要向我们的类添加交换功能，具体操作如下†：（

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);
    }

    // ...
};

此处 解释了为什么公共朋友交换。）现在我们不仅可以交换我们的dumb_array，而且交换通常会更高效；它只是交换指针和大小，而不是分配和复制整个数组。除了功能和效率方面的优势之外，我们现在已经准备好实现复制和交换习惯。

言归正传，我们的赋值运算符是：

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)

现在，如果使用右值初始化 other，它将被移动构造 。完美的。同样，C++03 让我们通过按值获取参数来重用复制构造函数功能，C++11 也会在适当的时候自动选择移动构造函数。 （当然，正如前面链接的文章中提到的，可以完全省略值的复制/移动。）

复制和交换习惯用法就这样结束了。

---

脚注

*为什么我们将mArray设置为null？因为如果运算符中的任何其他代码抛出异常，则可能会调用 dumb_array 的析构函数；如果发生这种情况而没有将其设置为空，我们将尝试删除已经被删除的内存！我们通过将其设置为 null 来避免这种情况，因为删除 null 是一个无操作。

†还有其他主张，我们应该为我们的类型专门化 std::swap，提供类内 swap 以及自由函数 swap但这都是不必要的：任何对 swap 的正确使用都将通过非限定调用进行，并且我们的函数将通过 ADL。一个函数就可以了。

‡原因很简单：一旦您拥有了自己的资源，您就可以将其交换和/或移动 (C++11) 到任何需要的地方。通过在参数列表中进行复制，可以最大限度地优化。

††移动构造函数通常应为 noexcept，否则某些代码（例如 std::vector 调整大小逻辑）将使用复制构造函数，即使移动有意义。当然，只有当里面的代码不抛出异常时才将其标记为no except。

Answer 2

赋值的核心是两个步骤：拆除对象的旧状态和将其新状态构建为副本

基本上，这就是析构函数和复制构造函数所做的，所以第一个想法是委托工作给他们。然而，由于破坏不能失败，而构造可能会失败，我们实际上想以相反的方式进行：首先执行构造部分如果成功，则执行破坏性部分。复制和交换习惯用法就是这样做的一种方法：它首先调用类的复制构造函数来创建临时对象，然后将其数据与临时对象交换，然后让临时对象的析构函数销毁旧状态。
由于 swap() 应该永远不会失败，因此唯一可能失败的部分是复制构造。首先执行此操作，如果失败，则目标对象中不会发生任何更改。

在其精炼形式中，复制和交换是通过初始化赋值运算符的（非引用）参数来执行复制来实现的：

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

Answer 3

已经有一些很好的答案了。我将主要关注我认为他们缺少的东西 - 用复制和交换惯用法对“缺点”的解释......

什么是复制和交换习惯用法？

根据交换函数实现赋值运算符的一种方法：

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

基本思想是：

• 分配给对象时最容易出错的部分是确保获取新状态所需的任何资源（例如内存、描述符）

• 在修改当前状态之前可以尝试获取该资源如果创建了新值的副本，则对象的状态（即 *this），这就是为什么 rhs 被按值接受（即复制）而不是通过引用

  ，

• 交换本地副本 rhs 和 *this 的状态通常相对容易实现，没有潜在的失败/异常，因为本地副本不存在之后需要任何特定状态（只需要适合析构函数运行的状态，就像从 >= C++11 中移动的对象一样）

什么时候应该使用它？ （它解决了哪些问题[/create]？）

• 当您希望被分配的对象不受引发异常的分配的影响时，假设您拥有或可以编写交换 具有强大的异常保证，并且理想情况下不会失败/抛出..†

• 当您想要一个干净、简单的理解根据（更简单的）复制构造函数、交换和析构函数定义赋值运算符的可靠方法。

  • 以复制和交换方式完成的自分配避免了经常被忽视的边缘情况。‡

• 当在分配期间使用额外的临时对象而造成的任何性能损失或暂时较高的资源使用率对您的应用程序并不重要时。 ⁂

---

† swap 抛出：通常可以可靠地交换对象通过指针跟踪的数据成员，但对于没有无抛出交换的非指针数据成员，或者必须进行交换的非指针数据成员实现为 X tmp = lhs;左轴 = 右轴； rhs = tmp; 并且复制构造或赋值可能会抛出异常，仍然有可能失败，导​​致某些数据成员被交换而另一些则没有。这种潜力甚至适用于 C++03 std::string ，正如 James 对另一个答案的评论：

@wilhelmtell：在 C++03 中，没有提及 std::string::swap （由 std::swap 调用）可能引发的异常。在 C++0x 中，std::string::swap 是 noexcept 并且不能抛出异常。 – 詹姆斯·麦克内利斯，2010 年 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_);
    }
    ...
};

在自分配时，上面的代码删除了 x.p_;，将 p_ 指向新分配的堆区域，然后尝试读取未初始化的< /em> 其中的数据（未定义的行为），如果这没有做任何太奇怪的事情，copy 会尝试对每个刚刚破坏的“T”进行自分配！

---

⁂ 由于使用额外的临时变量（当操作员的参数是复制构造的），复制和交换习惯用法可能会导致效率低下或受到限制：

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）。

Answer 4

这个答案更像是对上面答案的补充和轻微修改。

在某些版本的 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 对象，因此将其作为参数传递在技术上是多余的。

Answer 5

当您处理 C++11 样式的分配器感知容器时，我想添加一句警告。交换和赋值的语义略有不同。

为了具体起见，让我们考虑一个容器 std::vector，其中 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。

• 如果 AT::propagate_on_container_move_assignment 为 std::true_type，则 fm 重新分配 a 的分配器b.get_allocator() 的值，否则不会，并且 a 继续使用其原始分配器。在这种情况下，需要单独交换数据元素，因为 a 和 b 的存储不兼容。

• 如果 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 中的一项重要操作，这有点“高级用例”，但这并非完全不可能，因为移动优化通常只有在您的类时才变得有趣。管理资源，而内存是最流行的资源之一。