(Here is the explanation why public friend swap.) Now not only can we swap our dumb_array's, but swaps in general can be more efficient; it merely swaps pointers and sizes, rather than allocating and copying entire arrays. Aside from this bonus in functionality and efficiency, we are now ready to implement the copy-and-swap idiom.

废话不多说，我们的赋值运算符是:

Without further ado, our assignment operator is:

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

    return *this;
}

就是这样！一举解决了三个问题.

And that's it! With one fell swoop, all three problems are elegantly tackled at once.

我们首先注意到一个重要的选择:参数参数是按值.虽然人们可以很容易地做到以下几点(事实上，这个习语的许多幼稚的实现都是如此):

We first notice an important choice: the parameter argument is taken by-value. While one could just as easily do the following (and indeed, many naive implementations of the idiom do):

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

    return *this;
}

我们失去了一个 重要的优化机会.不仅如此，这种选择在 C++11 中也很关键，后面会讨论.(一般来说，一个非常有用的指导方针如下:如果您要在函数中复制某些内容，请让编译器在参数列表中完成它.‡)

We lose an important optimization opportunity. Not only that, but this choice is critical in C++11, which is discussed later. (On a general note, a remarkably useful guideline is as follows: if you're going to make a copy of something in a function, let the compiler do it in the parameter list.‡)

无论哪种方式，这种获取资源的方法都是消除代码重复的关键:我们可以使用复制构造函数中的代码进行复制，而无需重复任何部分.现在副本已经制作好了，我们可以进行交换了.

Either way, this method of obtaining our resource is the key to eliminating code duplication: we get to use the code from the copy-constructor to make the copy, and never need to repeat any bit of it. Now that the copy is made, we are ready to swap.

请注意，在进入函数时，所有新数据都已分配、复制并准备好使用.这就是免费为我们提供强大的异常保证的原因:如果副本的构造失败，我们甚至不会进入函数，因此不可能更改 *this 的状态.(我们之前手动为强异常保证所做的事情，现在编译器正在为我们做事情；怎么样.)

Observe that upon entering the function that all the new data is already allocated, copied, and ready to be used. This is what gives us a strong exception guarantee for free: we won't even enter the function if construction of the copy fails, and it's therefore not possible to alter the state of *this. (What we did manually before for a strong exception guarantee, the compiler is doing for us now; how kind.)

此时我们是无家可归的，因为 swap 是不抛出的.我们将当前数据与复制的数据交换，安全地更改我们的状态，并将旧数据放入临时数据中.当函数返回时，旧数据被释放.(参数的作用域结束并调用其析构函数.)

At this point we are home-free, because swap is non-throwing. We swap our current data with the copied data, safely altering our state, and the old data gets put into the temporary. The old data is then released when the function returns. (Where upon the parameter's scope ends and its destructor is called.)

因为成语没有重复代码，所以我们不能在操作符中引入错误.请注意，这意味着我们不再需要进行自分配检查，从而允许 operator= 的单一统一实现.(此外，我们不再对非自我分配产生性能损失.)

Because the idiom repeats no code, we cannot introduce bugs within the operator. Note that this means we are rid of the need for a self-assignment check, allowing a single uniform implementation of operator=. (Additionally, we no longer have a performance penalty on non-self-assignments.)

这就是复制和交换的习语.

And that is the copy-and-swap idiom.

C++ 的下一个版本，C++11，对我们管理资源的方式做出了一个非常重要的改变:三法则现在是四法则(半).为什么?因为我们不仅需要能够复制构建我们的资源，我们也需要移动构建它.

The next version of C++, C++11, makes one very important change to how we manage resources: the Rule of Three is now The Rule of Four (and a half). Why? Because not only do we need to be able to copy-construct our resource, we need to move-construct it as well.

幸运的是，这很容易:

class dumb_array
{
public:
    // ...

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

    // ...
};

这里发生了什么?回想一下移动构造的目标:从类的另一个实例中获取资源，使其处于保证可分配和可破坏的状态.

What's going on here? Recall the goal of move-construction: to take the resources from another instance of the class, leaving it in a state guaranteed to be assignable and destructible.

所以我们所做的很简单:通过默认构造函数(C++11 的一个特性)进行初始化，然后与 other 进行交换；我们知道可以安全地分配和销毁我们类的默认构造实例，因此我们知道 other 将能够在交换后做同样的事情.

So what we've done is simple: initialize via the default constructor (a C++11 feature), then swap with other; we know a default constructed instance of our class can safely be assigned and destructed, so we know other will be able to do the same, after swapping.

(请注意，有些编译器不支持构造函数委托；在这种情况下，我们必须手动默认构造类.这是一个不幸但幸运的是微不足道的任务.)

(Note that some compilers do not support constructor delegation; in this case, we have to manually default construct the class. This is an unfortunate but luckily trivial task.)

这是我们需要对类进行的唯一更改，为什么它会起作用?请记住我们做出的让参数成为值而不是引用的重要决定:

That is the only change we need to make to our class, so why does it work? Remember the ever-important decision we made to make the parameter a value and not a reference:

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

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

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.

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

*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.一个函数就可以了.

†There are other claims that we should specialize std::swap for our type, provide an in-class swap along-side a free-function swap, etc. But this is all unnecessary: any proper use of swap will be through an unqualified call, and our function will be found through ADL. One function will do.

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

‡The reason is simple: once you have the resource to yourself, you may swap and/or move it (C++11) anywhere it needs to be. And by making the copy in the parameter list, you maximize optimization.

††移动构造函数一般应该是noexcept，否则一些代码(例如std::vector调整大小的逻辑)即使移动会使用复制构造函数感觉.当然，只有在里面的代码没有抛出异常的情况下才标记为noexcept.

††The move constructor should generally be noexcept, otherwise some code (e.g. std::vector resizing logic) will use the copy constructor even when a move would make sense. Of course, only mark it noexcept if the code inside doesn't throw exceptions.

这篇关于什么是复制和交换成语?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持编程学习网！