The Rule of Five

The Rule of Five is a guideline in C++ that suggests that if a class defines any of the following special member functions, it should probably define all five:

1. Destructor
2. Copy constructor
3. Copy assignment operator
4. Move constructor
5. Move assignment operator

The reasoning behind this rule is that these functions are usually interconnected. If a class needs to define one of them for correct operation, it likely needs to define the others as well.

For example, if a class manages a resource (like dynamically allocated memory) and defines a custom destructor to release that resource, it should also define a copy constructor and copy assignment operator to properly copy that resource. Otherwise, copying the object could lead to issues like double-deletion of the resource.

When C++11 introduced move semantics, the Rule of Five was born as an extension of the Rule of Three (which covered only the destructor, copy constructor, and copy assignment operator). If a class defines a move constructor or move assignment operator, it's probably because it manages a resource that can be efficiently moved. In that case, it should also define the destructor and copy operations for completeness.

Here's an example of a class that follows the Rule of Five:

1class Resource {
2 public:
3  // Default constructor
4  Resource();
5
6  // Destructor
7  ~Resource();
8
9  // Copy constructor
10  Resource(const Resource& other);
11
12  // Copy assignment
13  Resource& operator=(const Resource& other);
14
15  // Move constructor
16  Resource(Resource&& other);
17
18  // Move assignment
19  Resource& operator=(Resource&& other);
20
21 private:
22  // ...
23};

By defining all five special member functions, Resource ensures that it can be constructed, destroyed, copied, and moved correctly, providing a complete and consistent interface.