什么是复制和交换成语？

我就是我 2024-03-30 16:24 82阅读 0赞

## 问： ##

什么是复制和交换习语，什么时候应该使用它？它解决了哪些问题？对于 C++11，它会改变吗？

有关的：

你最喜欢的 C++ 编码风格习语是什么：Copy-swap

C ++中的复制构造函数和=运算符重载：通用函数可能吗？

什么是复制省略以及它如何优化复制和交换习语

C++：动态分配对象数组？

## 答1: ##

> HuntsBot周刊–不定时分享成功产品案例，学习他们如何成功建立自己的副业–huntsbot.com

概述

为什么我们需要复制和交换习语？

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

copy-and-swap idiom 是解决方案，它优雅地帮助赋值运算符实现两件事：避免 code duplication 和提供 strong exception guarantee。

它是如何工作的？

Conceptually，它通过使用复制构造函数的功能来创建数据的本地副本，然后使用 swap 函数获取复制的数据，将旧数据与新数据交换。然后临时副本销毁，并带走旧数据。我们留下了新数据的副本。

为了使用 copy-and-swap 习惯用法，我们需要三样东西：一个有效的复制构造函数、一个有效的析构函数（两者都是任何包装器的基础，所以无论如何都应该是完整的）和一个 swap 函数。

交换函数是一个非抛出函数，它交换一个类的两个对象，成员对成员。我们可能会想使用 std::swap 而不是自己提供，但这是不可能的； std::swap 在其实现中使用复制构造函数和复制赋值运算符，我们最终会尝试根据自身定义赋值运算符！

（不仅如此，对 swap 的非限定调用将使用我们的自定义交换运算符，跳过 std::swap 所需要的对我们类的不必要的构造和破坏。）

深入的解释

目标

让我们考虑一个具体的案例。我们想在一个无用的类中管理一个动态数组。我们从一个有效的构造函数、复制构造函数和析构函数开始：

#include  // std::copy
    #include  // 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=(constdumb\_array& other) \{ if (this != &other) // (1) \{ // 在我们替换旧的 std::size\_t newSize = other.mSize 之前准备好新数据； int* newArray = newSize ？新 intnewSize : nullptr; // (3) std::copy(other.mArray, other.mArray + newSize, newArray); // (3) // 替换旧数据（都是非抛出的） delete \[\] mArray; mSize = newSize; mArray = newArray; \} 返回 \*this;代码已扩展！这就引出了第三个问题：代码重复。

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

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

（有人可能想知道：如果需要这么多代码来正确管理一个资源，如果我的班级管理多个资源怎么办？虽然这似乎是一个有效的问题，但确实需要不平凡的try/ catch 子句，这不是问题。那是因为一个类应该管理 one resource only！）

一个成功的解决方案

如前所述，复制和交换习语将解决所有这些问题。但是现在，除了一个 swap 函数之外，我们拥有所有要求。虽然三法则成功地包含了我们的复制构造函数、赋值运算符和析构函数，但它确实应该被称为“三巨头半”：任何时候你的类管理资源时，提供一个 \{ 1\}功能。

我们需要为我们的类添加交换功能，我们这样做如下†：

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

（Here 是 public friend swap 的解释。）现在我们不仅可以交换我们的 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;
    }

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

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

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

在这一点上，我们是无家可归的，因为 swap 是非投掷的。我们将当前数据与复制的数据交换，安全地更改我们的状态，并将旧数据放入临时数据中。当函数返回时，旧数据被释放。 （参数的作用域在哪里结束并调用它的析构函数。）

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

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

那么 C++11 呢？

C++ 的下一个版本 C++11 对我们管理资源的方式做出了一个非常重要的改变：三法则现在是四法则（半）。为什么？因为我们不仅需要能够复制构建我们的资源，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);
        }
    
        // ...
    };

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

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

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

为什么这行得通？

这是我们需要对我们的班级做出的唯一改变，那么为什么它会起作用呢？请记住我们做出的使参数成为值而不是引用的重要决定：

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

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

复制和交换的习语就这样结束了。

脚注

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

†还有其他主张，我们应该为我们的类型专门化 std::swap，提供一个类内 swap 以及一个自由函数 swap，等等。但这都是不必要的：任何正确使用 swap将通过不合格的调用，我们的函数将通过 ADL 找到。一个功能就可以了。

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

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

`@GMan：我认为一次管理多个资源的类注定要失败（异常安全变得像噩梦一样），我强烈建议一个类管理一个资源，或者它具有业务功能和使用管理器。`

`我不明白为什么交换方法在这里被声明为朋友？`

`@neuviemeporte：使用括号，数组元素默认初始化。没有，它们是未初始化的。因为在复制构造函数中我们无论如何都会覆盖这些值，所以我们可以跳过初始化。`

`@neuviemeporte：如果您希望 swap 在您会遇到的大多数通用代码中工作，您需要在 ADL 期间找到您的 swap，例如 boost::swap 和其他各种交换实例。交换是 C++ 中的一个棘手问题，通常我们都同意单点访问是最好的（为了保持一致性），而通常唯一的方法是使用自由函数（int 不能有例如交换成员）。有关背景信息，请参阅 my question。`

`@BenHymers：是的。复制和交换习语仅旨在以一般方式简化新资源管理类的创建。对于每个特定的班级，几乎可以肯定有一条更有效的路线。这个成语只是行之有效，而且很难做错。`

## 答2: ##

> huntsbot.com聚合了超过10+全球外包任务平台的外包需求，寻找外包任务与机会变的简单与高效。

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

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

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

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

`我认为提及 pimpl 与提及复制、交换和销毁一样重要。交换并不是神奇的异常安全。它是异常安全的，因为交换指针是异常安全的。您不必使用 pimpl，但如果不使用，则必须确保成员的每个交换都是异常安全的。当这些成员可以改变时，这可能是一场噩梦，而当他们隐藏在一个粉刺后面时，这将是微不足道的。然后，然后是粉刺的成本。这使我们得出结论，异常安全通常会带来性能成本。`

`std::swap(this_string, that) 不提供不投掷保证。它提供了强大的异常安全性，但不是不抛出保证。`

`@wilhelmtell：在 C++03 中，没有提到 std::string::swap（由 std::swap 调用）可能引发的异常。在 C++0x 中，std::string::swap 是 noexcept，并且不能抛出异常。`

`@sbi @JamesMcNellis 好的，但重点仍然存在：如果您有 class-type 的成员，则必须确保交换它们是禁止的。如果您有一个作为指针的成员，那么这很简单。否则不是。`