C++ Copy-and-Swap模式：异常安全的资源管理 #

引言 #

Copy-and-Swap是C++中一种优雅的设计模式，它不仅能确保赋值运算符的异常安全性，还能统一处理拷贝和移动赋值。

copy-and-swap语义 #

直奔主题，正常我们写一个赋值构造函数大概是这样

person& operator=(const person& that) {
    if (this != &that) {
        delete[] name;
        // This is a dangerous point in the flow of execution!
        // We have temporarily invalidated the class invariants,
        // and the next statement might throw an exception,
        // leaving the object in an invalid state :(
        name = new char[strlen(that.name) + 1];
        strcpy(name, that.name);
        age = that.age;
    }
    return *this;
}

然而，这种赋值构造函数有两点需要注意：

需要确保不能自己对自己赋值，否则容易把自己的内存释放掉，导致crash
需要先释放自己的资源，再申请新资源，再拷贝，但申请新资源时，可能会产生exception，这会导致原对象处于一个invalid的状态，导致non exception safety

所以，就有了copy-and-swap的方式。

那什么copy-and-swap？直接看代码：

class String {
    char* str;
public:
    String& operator=(String s) // the pass-by-value parameter serves as a temporary
    {
        s.swap(*this); // Non-throwing swap
        return *this;
    } // Old resources released when destructor of s is called.

    void swap(String& s) noexcept // Also see non-throwing swap idiom
    {
        std::swap(this->str, s.str);
    }
};

当然也可以这样：

class String {
    char* str;
public:
    String& operator=(const String& s) {
        if (this != &s) {
            String(s).swap(*this); //Copy-constructor and non-throwing swap
        }
        // Old resources are released with the destruction of the temporary above
        return *this;
    }
    void swap(String& s) noexcept // Also see non-throwing swap idiom
    {
        std::swap(this->str, s.str);
    }
};

但还是不如这种优雅：

String& operator=(String s) // the pass-by-value parameter serves as a temporary
{
    s.swap(*this); // Non-throwing swap
    return *this;
} // Old resources released when destructor of s is called.

这种方式不仅方便，而且也做了进一步优化：

如果参数原来是个左值，会直接做拷贝，而其实这次拷贝无论在哪都无法避免
如果参数原来是右值或者临时对象，就节省了一次拷贝和析构，这也叫copy elision，这种operator也就统一赋值运算符

In C++11, such an assignment operator is known as a unifying assignment operator because it eliminates the need to write two different assignment operators: copy-assignment and move-assignment. As long as a class has a move-constructor, a C++11 compiler will always use it to optimize creation of a copy from another temporary (rvalue). Copy-elision is a comparable optimization in non-C++11 compilers to achieve the same effect.

小作业：文中提到了exception safety，大家对此怎么看？

参考文献