C++ 中的 Rule-of-Three c++c++11c++14

Three 为何物？所谓的 Three 其实就是 copy constrcutor (拷贝构造函数) 、copy assignment operator (拷贝赋值操作符) 和 destructor (析构函数) 。在介绍 Rule-of-Three 之前，我们回顾一下 C++ Class 的声明与定义。

class Empty { private: int _val { 0 }; };

类 Empty 十分简单，我没有为它赋予任何 data members (数据成员) 或显式地声明/定义 member functions (成员函数) 。但事实上，编译器会在必要时为类 Empty 合成必要的成员函数。此话何解？我们不妨来看一下示例。

int main() { Empty e1 {}; // 创建一个Empty对象 Empty e2 { e1 }; // 通过一个已有的Empty对象给另外一个Empty对象初始化 Empty e3; e3 = e2; // 通过一个已有的Empty对象给另外一个Empty对象初始化 }

【C++ 中的 Rule-of-Three】由于我没有为类 Empty 显式地编写构造函数函数，编译器自然会为我补充如下的一个 default constructor (默认构造函数) 。

// C++ 概念代码 Empty::Empty() { // 啥也不干 }

当我们需要通过 e1 去构造更多的相同类型对象的时候，编译器又帮我们做了以下的事情。编译器会为类 Empty 添加拷贝构造函数 Empty::Empty(const Empty&) 和拷贝赋值操作符 Empty& operator=(const Empty& other) 。
事实上就类 Empty 的结构而言，编译器根本不需要生成拷贝构造函数和拷贝赋值操作符。因为类 Empty 里根本没有其他得 class object (类对象) 数据成员。编译器只需要通过 bitwise copy (位逐次拷贝) 把内存逐一拷贝便能完成任务。不过我们可以假设编译器会自动生成所需要的函数。

// C++ 概念代码 Empty::Empty(const Empty& other) { _val = other._val; }Empty& Empty::operator=(const Empty& other) { _val = other._val; return *this; }Empty::~Empty() { // 啥也不干 }

为什么要给 Three 定规则？我们已经对 Three 有了初步的了解，编译器可能会在背后为我们做了很多事情。不过助手毕竟也不过我们不能完全依赖编译器的行为。
由于类 Empty 添加了新的数据成员，所以我显式地声明并定义了构造函数 Empty::Empty(int, char) 。同时为了避免内存泄漏，我也添加了析构函数 Empty::~Empty() 。

class Empty { public: Empty(int val, char c) : _val(val), _cptr(new char(c)) {} ~Empty() { delete _cptr; }private: int _val { 0 }; char* _cptr { nullptr }; };

然后我尝试对类 Empty 的一些对象进行拷贝操作。此时编译器再次帮我添加两个成员函数。

Empty(const Empty& other) { _val = other._val; _cptr = other._cptr; }Empty& operator=(const Empty& other) { _val = other._val; _cptr = other._cptr; return *this; }

编译器真是帮了我一个大忙，自动帮我把 Empty e1 的成员逐个拷贝给 Empty e2 。不过遗憾的是，程序结束之前会崩溃。崩溃原因是 Empty::_cptr 被重复释放。因为它拷贝的是 Empty::_cptr 这个指针，而非 Empty::_cptr 这个指针指向的地址存放的值。

int main() { Empty e1(10, 'h'); auto e2 = e1; } // creash !!!

所以当 Three 同时存在的时候，为了让它们都 "安分守己"，我们必须给它们顶下规矩，这就是所谓的 Rule of Three 。
Rules Three 的问题在于，如果一个类里面有指针类型 (或者需要手动释放的资源类型) 的数据成员，编译器的位逐次拷贝会让程序变得不可靠。所以我们必须为让程序变得安全。基于上面的问题，我们有两个解决方案。要么这个类的对象是不允许被拷贝；要么这个类的对象允许被拷贝，但我们必须亲自重写这个类的 Three 。
方案一：

class Empty { public: // other user-definfed ctors ~Empty() { delete _cptr; }Empty(const Empty& other) = delete; Empty& operator=(const Empty& other) = delete; private: // data members };

方案二：

class Empty { public: // other user-definfed ctors ~Empty() { delete _cptr; }Empty(const Empty& other) { _val = other._val; if (_cptr != nullptr) // 检查 _cptr 的合法性很重要 delete _cptr; _cptr = new char(*other._cptr); }Empty& operator=(const Empty& other) { _val = other._val; if (_cptr != nullptr) // 同上 delete _cptr; _cptr = new char(*other._cptr); }private: // data members };

启发 C++ 的对象模型往往不是我们想象中的那么简单，编译器暗地里会做很多额外的工作。所以我们在管理类对象的资源的时候需要格外小心。