总览
为什么我们需要复制和交换习惯？
任何管理资源的类（包装器，如智能指针）都需要实现“三巨头”。尽管复制构造函数和析构函数的目标和实现很简单，但是复制分配运算符无疑是最细微和最困难的。应该怎么做？需要避免什么陷阱？
在复制和交换成语是解决方案，并协助典雅赋值运算符在实现两件事情：避免重复代码，并提供了一个强大的异常保证。
它是如何工作的？
从概念上讲，它通过使用复制构造函数的功能来创建数据的本地副本，然后将复制的数据与swap函数一起使用，将旧数据与新数据交换，从而起作用。然后，临时副本将销毁，并随身携带旧数据。我们剩下的是新数据的副本。
为了使用复制和交换习惯，我们需要三件事：一个有效的复制构造函数，一个有效的析构函数（两者都是任何包装程序的基础，因此无论如何都应完整）和一个swap功能。
交换函数是一种非抛出函数，它交换一个类的两个对象，一个成员一个成员。我们可能很想使用std::swap而不是提供我们自己的，但这是不可能的。std::swap在实现中使用copy-constructor和copy-assignment运算符，我们最终将尝试根据自身定义赋值运算符！
（不仅如此，对的不合格调用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)。
首先是自我分配测试。该检查有两个目的：这是一种防止我们在自赋值上运行不必要的代码的简便方法，并且可以保护我们免受细微的错误（例如删除数组以尝试复制它）。但是在所有其他情况下，它只是用来减慢程序运行速度，并在代码中充当噪声。自我分配很少发生，因此大多数时候这种检查都是浪费。如果没有它，操作员可以正常工作会更好。
第二个是它仅提供基本的异常保证。如果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;
}
代码已扩展！这导致我们遇到第三个问题：代码重复。我们的赋值运算符有效地复制了我们已经在其他地方编写的所有代码，这是很糟糕的事情。
在我们的案例中，它的核心只有两行（分配和复制），但是由于资源更加复杂，此代码膨胀可能很麻烦。我们应该努力避免重复自己。
（一个人可能会怀疑：如果需要大量的代码来正确地管理一种资源，那么如果我的班级要管理多个资源，该怎么办？这似乎是一个有效的问题，并且确实需要非平凡的try/ catch子句，但这是非必需的。-issue。这是因为类只能管理一个资源！）
成功的解决方案
如前所述，复制和交换惯用语将解决所有这些问题。但是现在，除了一个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的，而且一般而言，交换可以提高效率；它仅交换指针和大小，而不分配和复制整个数组。除了在功能和效率上获得这种奖励外，我们现在还可以实现复制和交换的习惯用法。
事不宜迟，我们的赋值运算符是：
dumb_array& operator=(dumb_array other) // (1)
{
swap(*this, other); // (2)
return *this;
}
就是这样！一口气，所有三个问题都可以轻松解决。
为什么行得通？
我们首先注意到一个重要的选择：参数自变量采用by-value。尽管可以很容易地完成以下操作（实际上，许多成语的幼稚实现都可以做到）：
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将自动在适当时选择move-constructor。（并且，当然，如先前链接的文章中所述，可以简单地完全省略复制/移动值。）
这样就得出了“复制和交换”的成语。
脚注
*为什么我们设置mArray为空？因为如果在运算符中抛出任何其他代码，则dumb_array可能会调用的析构函数；如果在没有将其设置为null的情况下发生这种情况，我们将尝试删除已经删除的内存！我们通过将其设置为null来避免这种情况，因为删除null是无操作的。
†还有其他主张，我们应该专门std::swap针对我们的类型，在类中提供swap自由函数swap，等等。但这都是不必要的：对的任何正确使用swap将通过不合格的调用进行，而我们的函数将通过ADL找到。一种功能将起作用。
‡原因很简单：一旦拥有了自己的资源，就可以在需要的任何地方交换和/或移动它（C ++ 11）。通过在参数列表中创建副本，可以最大程度地优化。
††move构造函数通常应为noexcept，否则std::vector即使在有意义的情况下，某些代码（例如，调整大小的逻辑）也将使用副本构造函数。当然，如果内部代码未引发异常，则仅将其标记为noexcept。
