C++基础: Rule of five/zero/three

Rule of five

在 C++ Core Guidelines 中，有这样的一条指导原则:

C.21: If you define or =delete any copy, move, or destructor function, define or =delete them all

就是说如果你定义了或者删除(=delete): 拷贝构造函数, 移动构造函数, 拷贝赋值函数, 移动赋值函数, 析构函数中的任意一个函数, 那么你需要定义或者删除它们全部. 注意: 普通的构造函数不在其中.

在通常情况下, 编译器会尝试为用户生成上面的 5 个函数. 编译器生成的函数的行为:

• 拷贝构造函数：按顺序拷贝构造每个成员变量
• 拷贝赋值运算符：按顺序拷贝赋值每个成员变量
• 移动构造函数：按顺序移动构造每个成员变量
• 移动赋值运算符：按顺序移动赋值每个成员变量
• 析构函数：按逆序销毁每个成员变量

但是如果用户定义了其中之一, 那么编译器的行为就会发生变化. 具体如下:

读者很难记住这个表格中的所有信息, 所以这会让使用者产生困惑. 为了让读者有个深切的体验, 后面我将举一个例子, 带大家一步步了解.

Simple String

我们以实现一个简单的字符串类为例:

1. 因为我们在构造的时候分配了存储空间, 所以需要加一个析构函数释放对应存储.

   struct SString {
     SString(char const* cp) : data_(new char[strlen(cp) + 1]) {
       strcpy(data_, cp);
     }
     ~SString() { delete[] data_; }
   
   private:
     char* data_;
   };
   

2. 如果现在有这样一个函数, 使用传值方式调用, 那该如何?

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

3. 这还没完, 如果此时有一个赋值语句, 程序就会出问题.

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

4. 此时的代码还有问题. 下面的情况下我们希望调用移动构造函数, 但是实际上会调用拷贝构造函数. 加个打印语句可以验证这一点.

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

5. 最后一个需要面对的场景就是移动赋值. 加上打印语句可以看出来当前的移动赋值调用了拷贝赋值函数.

   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 实现全部必要的函数.