함수 - 복사 및 스왑 관용구가 C++ 11의 복사 및 이동 관용구가되어야합니까?

복사생성자 사용이유 (2)

이 대답 에서 설명한 것처럼 복사 및 스왑 이디엄은 다음과 같이 구현됩니다.

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;
    }
};

operator =에 대한 매개 변수로 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);
    }
}

분명히이 수동으로 작성된 대입 연산자의 코드 부분은 이동 생성자의 코드 부분과 동일합니다. 할당 연산자에서 스왑을 수행 할 수는 있지만 동작이 올바르지 만 잠재적으로 더 많은 이동을 수행하고 추가 등록 (스왑에서) 및 등록 해제 (소멸자에서)를 수행합니다.

대신에 생성자의 코드를 재사용하는 것이 더 합리적이지 않습니까?

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

이 접근 방식이 스왑 방식보다 열등하지 않은 것처럼 보입니다. 복사 - 스왑 (copy-and-swap) 관용구가 C ++ 11에서 복사 및 이동 관용구로서 더 나을 것이라고 생각하는 것이 맞습니까? 아니면 중요한 것을 놓쳤습니까?