如 this answer 中所述， copy-and-swap 习语的实现方式如下:

class MyClass
{
private:
    BigClass data;
    UnmovableClass *dataPtr;

public:
    MyClass()
      : data(), dataPtr(new UnmovableClass) { }
    MyClass(const MyClass& other)
      : data(other.data), dataPtr(new UnmovableClass(*other.dataPtr)) { }
    MyClass(MyClass&& other)
      : data(std::move(other.data)), dataPtr(other.dataPtr)
    { other.dataPtr= nullptr; }

    ~MyClass() { delete dataPtr; }

    friend void swap(MyClass& first, MyClass& second)
    {
        using std::swap;
        swap(first.data, other.data);
        swap(first.dataPtr, other.dataPtr);
    }

    MyClass& operator=(MyClass other)
    {
        swap(*this, other);
        return *this;
    }
};

通过将 MyClass 值作为 operator= 的参数，该参数可以由复制构造函数或 move 构造函数构造。然后，您可以安全地从参数中提取数据。这可以防止代码重复并有助于异常安全。

答案提到您可以交换或 move 临时变量。它主要讨论交换。但是，如果没有经过编译器优化，交换会涉及三个 move 操作，并且在更复杂的情况下会做额外的额外工作。当您想要的只是将临时对象 move 到分配对象中。

考虑这个更复杂的例子，涉及 observer pattern .在此示例中，我手动编写了赋值运算符代码。重点是move构造函数、赋值运算符和swap方法:

class MyClass : Observable::IObserver
{
private:
    std::shared_ptr<Observable> observable;

public:
    MyClass(std::shared_ptr<Observable> observable) : observable(observable){ observable->registerObserver(*this); }
    MyClass(const MyClass& other) : observable(other.observable) { observable.registerObserver(*this); }
    ~MyClass() { if(observable != nullptr) { observable->unregisterObserver(*this); }}

    MyClass(MyClass&& other) : observable(std::move(other.observable))
    {
        observable->unregisterObserver(other);
        other.observable.reset(nullptr);
        observable->registerObserver(*this);
    }

    friend void swap(MyClass& first, MyClass& second)
    {
        //Checks for nullptr and same observable omitted
            using std::swap;
            swap(first.observable, second.observable);

            second.observable->unregisterObserver(first);
            first.observable->registerObserver(first);
            first.observable->unregisterObserver(second);
            second.observable->registerObserver(second);
    }

    MyClass& operator=(MyClass other)
    {
        observable->unregisterObserver(*this);
        observable = std::move(other.observable);

        observable->unregisterObserver(other);
        other.observable.reset(nullptr);
        observable->registerObserver(*this);
    }
}

显然，这个手动编写的赋值运算符中的重复部分代码与 move 构造函数中的重复部分相同。您可以在赋值运算符中执行交换并且行为是正确的，但它可能会执行更多 move 并执行额外的注册(在交换中)和取消注册(在析构函数中)。

重用 move 构造函数的代码不是更有意义吗？

private:
    void performMoveActions(MyClass&& other)
    {
        observable->unregisterObserver(other);
        other.observable.reset(nullptr);
        observable->registerObserver(*this);
    }

public:
    MyClass(MyClass&& other) : observable(std::move(other.observable))
    {
        performMoveActions(other);
    }

    MyClass& operator=(MyClass other)
    {
        observable->unregisterObserver(*this);
        observable = std::move(other.observable);

        performMoveActions(other);
    }

在我看来，这种方法绝不逊色于交换方法。我是否认为在 C++11 中将 copy-and-swap 习语作为复制和 move 习语会更好，还是我错过了一些重要的事情？

最佳答案

首先，只要你的类是可 move 的，通常不需要在 C++11 中编写 swap 函数。默认的 swap 将诉诸 move :

void swap(T& left, T& right) {
    T tmp(std::move(left));
    left = std::move(right);
    right = std::move(tmp);
}

就是这样，元素被交换了。

其次，基于此，Copy-And-Swap 实际上仍然成立:

T& T::operator=(T const& left) {
    using std::swap;
    T tmp(left);
    swap(*this, tmp);
    return *this;
}

// Let's not forget the move-assignment operator to power down the swap.
T& T::operator=(T&&) = default;

将 copy-and-swap (这是一个 move )或 move 和交换(这是一个 move )，并且应该始终达到接近最佳性能。可能会有一些多余的分配，但希望你的编译器会处理它。

编辑: 这仅实现了复制赋值运算符；还需要一个单独的 move 赋值运算符，虽然它可以默认，否则会发生堆栈溢出( move 赋值和交换无限期地相互调用)。

关于c++ - Copy-and-Swap 成语是否应该成为 C++11 中的 Copy-and-Move 成语？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/24014130/