Rule of five
在 C++ Core Guidelines 中，有这样的一条指导原则:
C.21: If you define or
=deleteany copy, move, or destructor function, define or=deletethem all
就是说如果你定义了或者删除(=delete): 拷贝构造函数, 移动构造函数, 拷贝赋值函数, 移动赋值函数, 析构函数中的任意一个函数, 那么你需要定义或者删除它们全部. 注意: 普通的构造函数不在其中.
在通常情况下, 编译器会尝试为用户生成上面的 5 个函数. 编译器生成的函数的行为:
- 拷贝构造函数：按顺序拷贝构造每个成员变量
- 拷贝赋值运算符：按顺序拷贝赋值每个成员变量
- 移动构造函数：按顺序移动构造每个成员变量
- 移动赋值运算符：按顺序移动赋值每个成员变量
- 析构函数：按逆序销毁每个成员变量
但是如果用户定义了其中之一, 那么编译器的行为就会发生变化. 具体如下:
读者很难记住这个表格中的所有信息, 所以这会让使用者产生困惑. 为了让读者有个深切的体验, 后面我将举一个例子, 带大家一步步了解.
Simple String
我们以实现一个简单的字符串类为例:
-
因为我们在构造的时候分配了存储空间, 所以需要加一个析构函数释放对应存储.
struct SString {SString(char const* cp) : data_(new char[strlen(cp) + 1]) {strcpy(data_, cp);}~SString() { delete[] data_; }private:char* data_; }; -
如果现在有这样一个函数, 使用传值方式调用, 那该如何?
void fun(SString val) {//... }这个时候因为编译器生成的拷贝函数会按位拷贝, 也就是两个实例的
data_指针指向同一个地址, 这样会造成调用两次析构函数, 有重复释放的问题. 因此我们此时需要修改拷贝构造函数.
于是代码进一步变成这样:struct SString {SString(char const* cp) : data_(new char[strlen(cp) + 1]) {strcpy(data_, cp);}~SString() { delete[] data_; }SString(SString const& rhs) : data_(new char[strlen(rhs.data_) + 1]) {strcpy(data_, rhs.data_);}private:char* data_; }; -
这还没完, 如果此时有一个赋值语句, 程序就会出问题.
SString src{"I’m going to be copied"}; SString dst{"I have a value"}; // … dst = src;此时我们需要自定义一个拷贝赋值函数. 不能使用默认的拷贝赋值.
#include <cstdlib> #include <cstring> #include <utility>struct SString {SString(char const* cp) : data_(new char[strlen(cp) + 1]) {strcpy(data_, cp);}~SString() { delete[] data_; }SString(SString const& rhs) : data_(new char[strlen(rhs.data_) + 1]) {strcpy(data_, rhs.data_);}SString& operator=(SString const& rhs) {char* newdata = new char[strlen(rhs.data_) + 1];strcpy(newdata, rhs.data_);std::swap(newdata, data_);delete[] newdata;return *this;}private:char* data_; };void fun(SString val) {//... }int main() {SString s("Hello, World!");fun(s);SString src{"I’m going to be copied"};SString dst{"I have a value"};// …dst = src;return 0; } -
此时的代码还有问题. 下面的情况下我们希望调用移动构造函数, 但是实际上会调用拷贝构造函数. 加个打印语句可以验证这一点.
SString s{"I'm temporary"}; fun(std::move(s));为了正确支持 move, 我们需要定义一个移动构造函数.
struct SString {SString(char const* cp) : data_(new char[strlen(cp) + 1]) {strcpy(data_, cp);}~SString() { delete[] data_; }SString(SString const& rhs) : data_(new char[strlen(rhs.data_) + 1]) {std::cout << "copy constructor" << std::endl;strcpy(data_, rhs.data_);}SString& operator=(SString const& rhs) {std::cout << "copy assign" << std::endl;char* newdata = new char[strlen(rhs.data_) + 1];strcpy(newdata, rhs.data_);std::swap(newdata, data_);delete[] newdata;return *this;}SString(SString&& rhs) noexcept : data_(rhs.data_) {rhs.data_ = nullptr;std::cout << "move constructor" << std::endl;}private:char* data_; }; -
最后一个需要面对的场景就是移动赋值. 加上打印语句可以看出来当前的移动赋值调用了拷贝赋值函数.
SString src{"hello"}; SString dst{"world"}; dst = std::move(src);需要实现一个移动赋值函数.
struct SString {SString(char const* cp) : data_(new char[strlen(cp) + 1]) {strcpy(data_, cp);}~SString() { delete[] data_; }SString(SString const& rhs) : data_(new char[strlen(rhs.data_) + 1]) {std::cout << "copy constructor" << std::endl;strcpy(data_, rhs.data_);}SString& operator=(SString const& rhs) {std::cout << "copy assign" << std::endl;char* newdata = new char[strlen(rhs.data_) + 1];strcpy(newdata, rhs.data_);std::swap(newdata, data_);delete[] newdata;return *this;}SString(SString&& rhs) noexcept : data_(rhs.data_) {rhs.data_ = nullptr;std::cout << "move constructor" << std::endl;}SString& operator=(SString&& rhs) {std::cout << "move assign" << std::endl;delete[] data_;data_ = rhs.data_;rhs.data_ = nullptr;return *this;}private:char* data_; };
所以, 为了一个简单的类, 我们需要定义 5 个函数. 能避免还是要尽量避免这样做.
Rule of zero
在 C++ Core Guidelines 中, C.20这样写:
C.20: If you can avoid defining any default operations, do
C.20的意思是: 如果你可以避免定义任何默认操作, 那么你就应该避免.
对上面的简单字符串类来说, 如果你只是扩展功能, 那么完全不用自己管理空间, 托管给std::string(或者其他 RAII 类)即可.
struct EString {EString(char const * cp) : data_(cp) {}std::string data_;
};
Rule of three
在 C++11 之前, 没有移动构造和移动赋值函数, 所以减去这两个就剩 3 个函数了. 也就是他们基于类似的考虑, 但是数量不一样而已.
总结
实际工作中如果有能用的工具类尽量使用工具类(Rule of zero), 当然如果你是那个要造轮子的人, 那么请遵从 Rule of Five 实现全部必要的函数.
