![\"RuleOfZeroFiveSix\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/08\/RuleOfZeroFiveSix.png\")
<\/p>\nThis post is about the rule of zero, five, or maybe six. I will also show the difference between copy and reference semantics and a quite similar topic: deep versus shallow copy.<\/p>\n
<\/p>\n
To be precise, C++ has about 50 rules for managing the lifecycle of an object. This time I will write about the three fundamental default operation rules. I provide you with the link to each of the rules of the C++ core guidelines. If necessary, you can read the details following the link. Let’s start.<\/p>\n
C++ provides six default operations, sometimes called special functions, for managing the lifecycle of an object. Consequently, this first post to the lifecycle of objects has to start with the six operations. <\/p>\n
<\/p>\n
X()<\/code><\/li>\n- a copy constructor:
X(const X&)<\/code><\/li>\n- a copy assignment:
operator=(const X&)<\/code><\/li>\n- a move constructor:
X(X&&)<\/code><\/li>\n- a move assignment:
operator=(X&&)<\/code><\/li>\n- a destructor:
~X()<\/code><\/li>\n<\/ul>\nThe default operations are related. This means if you implement or =delete one of them, you have to think about the five others. The word implement may seem a bit confusing. For the default constructor, it means that you can define it or request it from the compiler:<\/p>\n
<\/p>\n
\nX(){}; \/\/ explicitly defined<\/span>\r\nX() =<\/span> default<\/span>; \/\/ requested from the compiler<\/span>\r\n<\/pre>\n<\/div>\n <\/p>\n
This rule also holds for the five other default operations.<\/p>\n
One general remark before I write about the set of default operations rules. C++ provides value semantics and not reference semantics for its types. Here is the best definition I found of both terms from https:\/\/isocpp.org\/wiki\/faq\/value-vs-ref-semantics<\/a>. <\/p>\n\n- Value semantic<\/strong>: Value (or \u201ccopy\u201d) semantics mean assignment copies the value, not just the pointer.<\/li>\n
- Reference semantic:<\/strong> With reference semantics, the assignment is a pointer-copy (i.e., a reference<\/em>).<\/li>\n<\/ul>\n
Here are the first three rules:<\/p>\n
Set of default operations rules:<\/h2>\n\n- C.20: If you can avoid defining any default operations, do<\/a><\/li>\n
- C.21: If you define or
=delete<\/code> any default operation, define or =delete<\/code> them all<\/a><\/li>\n- C.22: Make default operations consistent<\/a><\/li>\n<\/ul>\n
C.20: If you can avoid defining any default operations, do<\/a><\/h3>\nThis rule is also known as “the rule of zero<\/strong>“. That means you are done if your class needs no default operations because all its members have the six special functions.<\/p>\n<\/p>\n
\nstruct<\/span> Named_map {\r\npublic:<\/span>\r\n \/\/ ... no default operations declared ...<\/span>\r\nprivate:<\/span>\r\n string name;\r\n map<<\/span>int<\/span>, int<\/span>><\/span> rep;\r\n};\r\n\r\nNamed_map nm; \/\/ default construct<\/span>\r\nNamed_map nm2 {nm}; \/\/ copy construct<\/span>\r\n<\/pre>\n<\/div>\n <\/p>\n
The default and copy construction will work because they are already defined for std::string<\/span> and std::map<\/span>.<\/p>\nC.21: If you define or =delete<\/code> any default operation, define or =delete<\/code> them all<\/a><\/h3>\nBecause we have to define or =delete all six of them, this rule is called “the rule of five<\/strong>“. Five seems strange to me. The reason for the rule of five or six is quite apparent. The six operations are closely related; therefore, the probability is high that you will get odd objects if you don’t follow the rule. Here is an example from the guidelines.<\/p>\n<\/p>\n
\nstruct<\/span> M2 { \/\/ bad: incomplete set of default operations<\/span>\r\npublic:<\/span>\r\n \/\/ ...<\/span>\r\n \/\/ ... no copy or move operations ...<\/span>\r\n ~<\/span>M2() { delete<\/span>[] rep; }\r\nprivate:<\/span>\r\n pair<<\/span>int<\/span>, int<\/span>>*<\/span> rep; \/\/ zero-terminated set of pairs<\/span>\r\n};\r\n\r\nvoid<\/span> use<\/span>()\r\n{\r\n M2 x;\r\n M2 y;\r\n \/\/ ...<\/span>\r\n x =<\/span> y; \/\/ the default assignment<\/span>\r\n \/\/ ...<\/span>\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
What is strange about this example? First, the destructor deletes rep,<\/span> which was never initialized. Second, and that is more serious. The default copy assignment operation (x = y)<\/span> in the last line copies all members of M2<\/span>. This means, in particular, that the pointer rep<\/span> will be copied. Hence, the destructor for x<\/span> and y<\/span> will be called, and we get undefined behavior because of double deletion.<\/p>\nC.22: Make default operations consistent<\/a><\/h3>\nThis rule is related to the previous rule. If you implement the default operations with different semantics, the class users may be confused. This is the reason I constructed the class Strange.<\/span> To observe the odd behavior, Strange includes a pointer to int.<\/p>\n<\/p>\n
\n\/\/ strange.cpp<\/span> (https:\/\/github.com\/RainerGrimm\/ModernesCppSource)<\/span>
#include <iostream><\/span>\r\n\r\nstruct<\/span> Strange{ \r\n \r\n Strange():<\/span> p(new<\/span> int<\/span>(2011<\/span>)){}\r\n \r\n \/\/ deep copy <\/span>\r\n Strange(const<\/span> Strange&<\/span> a) :<\/span> p(new<\/span> int<\/span>(*<\/span>(a.p))){} \/\/ (1)<\/span>\r\n \r\n \/\/ shallow copy<\/span>\r\n Strange&<\/span> operator<\/span>=<\/span>(const<\/span> Strange&<\/span> a){ \/\/ (2)<\/span>\r\n p =<\/span> a.p;\r\n return<\/span> *<\/span>this<\/span>;\r\n } \r\n \r\n int<\/span>*<\/span> p;\r\n \r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n \r\n std::<\/span>cout <<<\/span> \"Deep copy\"<\/span> <<<\/span> std::<\/span>endl;\r\n \r\n Strange s1;\r\n Strange s2(s1); \/\/ (3)<\/span>\r\n \r\n std::<\/span>cout <<<\/span> \"s1.p: \"<\/span> <<<\/span> s1.p <<<\/span> \"; *(s1.p): \"<\/span> <<<\/span> *<\/span>(s1.p) <<<\/span> std::<\/span>endl;\r\n std::<\/span>cout <<<\/span> \"s2.p: \"<\/span> <<<\/span> s2.p <<<\/span> \"; *(s2.p): \"<\/span> <<<\/span> *<\/span>(s2.p) <<<\/span> std::<\/span>endl;\r\n \r\n std::<\/span>cout <<<\/span> \"*(s2.p) = 2017\"<\/span> <<<\/span> std::<\/span>endl;\r\n *<\/span>(s2.p) =<\/span> 2017<\/span>; \/\/ (4)<\/span>\r\n \r\n std::<\/span>cout <<<\/span> \"s1.p: \"<\/span> <<<\/span> s1.p <<<\/span> \"; *(s1.p): \"<\/span> <<<\/span> *<\/span>(s1.p) <<<\/span> std::<\/span>endl;\r\n std::<\/span>cout <<<\/span> \"s2.p: \"<\/span> <<<\/span> s2.p <<<\/span> \"; *(s2.p): \"<\/span> <<<\/span> *<\/span>(s2.p) <<<\/span> std::<\/span>endl;\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n \r\n std::<\/span>cout <<<\/span> \"Shallow copy\"<\/span> <<<\/span> std::<\/span>endl;\r\n\r\n Strange s3;\r\n s3 =<\/span> s1; \/\/ (5)<\/span>\r\n \r\n std::<\/span>cout <<<\/span> \"s1.p: \"<\/span> <<<\/span> s1.p <<<\/span> \"; *(s1.p): \"<\/span> <<<\/span> *<\/span>(s1.p) <<<\/span> std::<\/span>endl;\r\n std::<\/span>cout <<<\/span> \"s3.p: \"<\/span> <<<\/span> s3.p <<<\/span> \"; *(s3.p): \"<\/span> <<<\/span> *<\/span>(s3.p) <<<\/span> std::<\/span>endl;\r\n \r\n \r\n std::<\/span>cout <<<\/span> \"*(s3.p) = 2017\"<\/span> <<<\/span> std::<\/span>endl;\r\n *<\/span>(s3.p) =<\/span> 2017<\/span>; \/\/ (6)<\/span>\r\n \r\n std::<\/span>cout <<<\/span> \"s1.p: \"<\/span> <<<\/span> s1.p <<<\/span> \"; *(s1.p): \"<\/span> <<<\/span> *<\/span>(s1.p) <<<\/span> std::<\/span>endl;\r\n std::<\/span>cout <<<\/span> \"s3.p: \"<\/span> <<<\/span> s3.p <<<\/span> \"; *(s3.p): \"<\/span> <<<\/span> *<\/span>(s3.p) <<<\/span> std::<\/span>endl;\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n \r\n std::<\/span>cout <<<\/span> \"delete s1.p\"<\/span> <<<\/span> std::<\/span>endl; \r\n delete<\/span> s1.p; \/\/ (7)<\/span>\r\n \r\n std