In C++, classes and structs are one of the most important parts of modern application development. In modern C++, there are some rules to support the principles of programming, one of which is the Rule of Six in C++ (also known as the Rule of Five, excluding the constructor). In this post, we explain the Rule of Six in C++ with examples.
C++ is an Object-Oriented Programming (OOP) language, and OOP is a way to integrate with objects which can contain data in the form (attributes or properties of objects), and code blocks in the form of procedures (methods, functions of objects). Most developers find that using OOP techniques help them to map real-world behavior and bring an organizational structure to data. These attributes and methods are variables and functions that belong to the class – part of the class’s code and they are generally referred to as class members.
First, let’s refresh our memory about the fact that Resource Acquisition Is Initialization (RAII) in OOP programming, and the Single Responsibility Principle and how that relates to the Rule of Zero in C++.
Table of Contents
What is resource acquisition in C++?
The principle of Resource Acquisition Is Initialization (RAII) term used in several OOP programming languages, which relates to the ability to manage resources, such as memory, through the copy and move constructors, destruction, and assignment operators. RAII is about the declaration and use of destructors, copy-move operators, and memory management in these members and methods. These cause new rules in development.
What is the single responsibility principle in C++?
The Single Responsibility Principle (SRP) is a computer programming principle that states “A module should be responsible to one, and only one, actor.” This principle exposes a rule for the classes in C++, called Rule of Zero. Now, let’s see what the Rule of Zero in C++ is.
What is the rule of zero in C++?
The Rule of Zero means that, if all members have default member functions, no further work is needed. This is the simplest and cleanest semantics of programming. The compiler provides default implementations for all of the default member functions if there are no special member functions that are user-defined. You should prefer the case where no special member functions need to be defined.
Here is more about Rule of Zero with C++ Examples,
What is the rule of three in C++?
The Rule of Three states that if you need to define a class that has any of the following special member functions a copy constructor, copy assignment operator, or destructor then usually you need to define all these three special member functions. So, these 3 special member functions below should be defined if you have at least one of them defined,
- Copy constructor
- Copy assignment operator
- Destructor
Here is more about Rule of Three with C++ examples,
What is the rule of six in C++?
The Rule of Three is outdated after C++11. C++11 comes with two additional special members of move semantics: the move constructor and the move assignment operator. So, there is another rule, the Rule of Six.
The Rule of Six states that if you need to define any of the six special members below,
- constructor
- copy constructor,
- copy assignment operator,
- move constructor,
- move assignment operator,
- or a destructor
then you probably need to define or delete (or at least consider) all six of them.
This rule also known as “The Rule of Five“, because the default constructor is special, and, therefore, sometimes excluded. Note that, when you define copy / move constructor you need to define constructor too, so the constructor needs to be added.
If you have a compiler that is compatible with the C++11 standard or over then if you need to define any of the six (or five) special members as in examples below.
Is there a simple example of the rule of six in C++?
Note that, a simple empty C++ class is perfectly equivalent to default implementations (Rule of Six) in a class. A modern compiler is able to provide all these special member functions (default implementations). In example, this simple class below:
|
1 2 3 4 5 6 |
class Tx { }; |
is exactly the same as this one in modern C++.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
class Tx { public: Tx() = default; // 1. constructor Tx(Tx const& other) = default; // 2. copy constructor Tx(Tx&& other) = default; // 3. move constructor Tx& operator=(Tx const& other) = default; // 4. copy assignment operator Tx& operator=(Tx&& other) = default; // 5. move assignment operator ~Tx() = default; // 6. destructor }; |
Is there an example of the rule of six with defined members in C++?
As you can see, in modern C++, these 5 special members are automatically generated as a default for each new class. If you need to define one of them, you should define all of these members as in this example below,
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
class Tx { public: std::string str; Tx() // 1. constructor { } Tx(Tx const& other) // 2. copy constructor { } Tx(Tx&& other) // 3. move constructor { } Tx& operator=(Tx const& other) // 4. copy assignment operator { } Tx& operator=(Tx&& other) // 5. move assignment operator { } ~Tx() // 6. destructor { } }; |
Is there a full example of how to use the rule of six in C++?
Here is a full example of the rule of six in modern C++.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 |
#include <iostream> #include <string> class Tx { public: std::string str; Tx() // 1. constructor { } Tx(Tx const& other) // 2. copy constructor { } Tx(Tx&& other) // 3. move constructor { } Tx& operator=(Tx const& other) // 4. copy assignment operator { } Tx& operator=(Tx&& other) // 5. move assignment operator { } ~Tx() // 6. destructor { } }; int main() { Tx o1; // 1. Using Constructor o1.str = "LearnCplusplus.org"; Tx o2(o1); // 2. Using Copy Constructor Tx o3 = std::move(o1); // 3. Using Move Constructor o2 = o1; // 4. Using Copy Assignment Operator o3 = std::move(o2); // 5. Using Move Assignment Operator return 0; // 6. Using Destructor } |
As you see in modern C++ these 6 special members are automatically generated as a default in simple class, if you need to define one of them (excluding constructor) you should define all of them.
C++ Builder is the easiest and fastest C and C++ IDE for building simple or professional applications on the Windows, MacOS, iOS & Android operating systems. It is also easy for beginners to learn with its wide range of samples, tutorials, help files, and LSP support for code. RAD Studio’s C++ Builder version comes with the award-winning VCL framework for high-performance native Windows apps and the powerful FireMonkey (FMX) framework for cross-platform UIs.
There is a free C++ Builder Community Edition for students, beginners, and startups; it can be downloaded from here. For professional developers, there are Professional, Architect, or Enterprise version.
Design. Code. Compile. Deploy.
Start Free Trial
Free C++Builder Community Edition
