在C++11中，复制和交换习语应该变成复制和移动习语吗

如本答案所述，复制和交换习惯用法实现如下：

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值作为运算符=的参数，该参数可以由复制构造函数或移动构造函数构造。然后可以安全地从参数中提取数据。这可以防止代码重复，并有助于异常安全。

答案提到，您可以交换或移动临时变量。它主要讨论交换。然而，如果编译器没有对交换进行优化，交换将涉及三个移动操作，在更复杂的情况下还会做额外的工作。当您只需要将临时对象移动到指定的对象中时。

考虑这个更复杂的例子，涉及观察者模式。在本例中，我手动编写了赋值运算符代码。重点是移动构造函数、赋值运算符和交换方法：

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构造函数的代码不是更有意义吗？

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中的复制和移动习惯用法更好，这是对的吗？还是我错过了一些重要的东西？