![\"stork](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/09\/stork-1324371_1280.png\")
<\/p>\nThe rules for copy and move are pretty obvious. But before I describe them I have to write about the two remaining rules for constructors. They are about delegating and inheriting constructors.<\/p>\n
<\/p>\n
Here are the two remaining rules:<\/p>\n
<\/p>\n
Since C++11, a constructor can delegate its work to another constructor of the same class. This is the modern way in C++ to put common actions for all constructors in one constructor. In C++ code before C++11, you often used for such a job an init<\/span> function.<\/p>\n <\/p>\n The constructors (2) and (3) of the class Degree<\/span> delegate all its initialization work to the constructor (1), which verifies its arguments. Invoking constructors recursively is undefined behavior.<\/p>\n<\/p>\n If you can reuse constructors of the base class in the derived class, do it. You violate the DRY (Don’t Repeat Yourself) principle if you don’t do it.<\/p>\n <\/p>\n There is a danger in using inheriting constructors. If your derived class, such as Rec2<\/span> has its own members, they are uninitialized (1).<\/p>\n The chapter starts with a meta-rule. Values types, which behave like an int, should be copyable, but interfaces in class hierarchies are not. The last rule C.67 refers to this meta-rule.<\/p>\n Here are the eight rules:<\/p>\n The first six rules for copy and move consist of 3 similar pairs; therefore, I can explain them together.<\/p>\n M This is the pattern the move operators of the standard template library follow. Have a look at std::vector.<\/span><\/p>\n <\/p>\n The last rule C.67 deserves more attention.<\/p>\n\nclass<\/span> Degree<\/span>{\r\npublic:<\/span>\r\n Degree(int<\/span> deg){ \/\/ (1)<\/span>\r\n degree=<\/span> deg %<\/span> 360<\/span>;\r\n if<\/span> (degree <<\/span> 0<\/span>) degree +=<\/span> 360<\/span>;\r\n }\r\n\r\n Degree():<\/span> Degree(0<\/span>){} \/\/ (2)<\/span>\r\n\r\n Degree(double<\/span> deg):<\/span> Degree(static_cast<\/span><<\/span>int<\/span>><\/span>(ceil(deg))){} \/\/ (3)<\/span>\r\n\r\nprivate:<\/span>\r\n int<\/span> degree;\r\n};\r\n<\/pre>\n<\/div>\nC.52: Use inheriting constructors to import constructors into a derived class that does not need further explicit initialization<\/a><\/h3>\n
\nclass<\/span> Rec<\/span> {\r\n \/\/ ... data and lots of nice constructors ...<\/span>\r\n};\r\n\r\nclass<\/span> Oper<\/span> :<\/span> public<\/span> Rec {\r\n using<\/span> Rec::<\/span>Rec;\r\n \/\/ ... no data members ...<\/span>\r\n \/\/ ... lots of nice utility functions ...<\/span>\r\n};\r\n\r\nstruct<\/span> Rec2 :<\/span> public<\/span> Rec {\r\n int<\/span> x;\r\n using<\/span> Rec::<\/span>Rec;\r\n};\r\n\r\nRec2 r {\"foo\"<\/span>, 7<\/span>};\r\nint<\/span> val =<\/span> r.x; \/\/ uninitialized (1)<\/span> \r\n<\/pre>\n<\/div>\nCopy and Move<\/h2>\n
![\"movers](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/09\/movers-24402_1280.png\")
<\/p>\n\n
virtual<\/code>, take the parameter by const&<\/code>, and return by non-const&<\/code><\/a><\/li>\nvirtual<\/code>, take the parameter by &&<\/code>, and return by non-const&<\/code><\/a><\/li>\nnoexcept<\/code><\/a><\/li>\nclone<\/code> instead, if \u201ccopying\u201d is desired<\/a><\/li>\n<\/ul>\n\n
\n
\n
\n
\n
\nvector&<\/span> operator<\/span>=<\/span>( const<\/span> vector&<\/span> other ); \t\r\nvector&<\/span> operator<\/span>=<\/span>( vector&&<\/span> other ); \/\/ (since C++11, until C++17)<\/span>\r\nvector&<\/span> operator<\/span>=<\/span>( vector&&<\/span> other ) noexcept \/\/ since C++17)
<\/span><\/pre>\n<\/div>\n<\/blockquote>\n<\/blockquote>\n\n
\n
\n
\n
\n
\n
\n
\nclass<\/span> Foo<\/span> {\r\n string s;\r\n int<\/span> i;\r\npublic:<\/span>\r\n Foo&<\/span> Foo::<\/span>operator<\/span>=<\/span>(const<\/span> Foo&<\/span> a){\r\n s =<\/span> a.s;\r\n i =<\/span> a.i;\r\n return<\/span> *<\/span>this<\/span>;\r\n }\r\n Foo&<\/span> Foo::<\/span>operator<\/span>=<\/span>(Foo&&<\/span> a) noexcept {\r\n s =<\/span> std::<\/span>move(a.s);\r\n i =<\/span> a.i;\r\n return<\/span> *<\/span>this<\/span>;
}
\/\/ ....
};<\/pre>\n<\/div>\n
<\/strong>The code snippet shows that there is no test for self-assignment such as in the next example necessar<\/b>y. Here is the version of the type Foo<\/span> with redundant (expensive) checks (1) and (2) for self-assignment.
<\/strong><\/p><\/blockquote>\n\n
\nclass<\/span> Foo<\/span> {\r\n string s;\r\n int<\/span> i;\r\npublic:<\/span>\r\n Foo&<\/span> Foo::<\/span>operator<\/span>=<\/span>(const<\/span> Foo&<\/span> a){\r\n if<\/span> (this<\/span> ==<\/span> &<\/span>a) return<\/span> *<\/span>this<\/span>; \/\/ (1)<\/span>\r\n s =<\/span> a.s;\r\n i =<\/span> a.i;\r\n return<\/span> *<\/span>this<\/span>;\r\n }\r\n Foo&<\/span> Foo::<\/span>operator<\/span>=<\/span>(Foo&&<\/span> a) noexcept { \/\/ (2)<\/span>\r\n if<\/span> (this<\/span> ==<\/span> &<\/span>a) return<\/span> *<\/span>this<\/span>;\r\n s =<\/span> std::<\/span>move(a.s);\r\n i =<\/span> a.i;\r\n return<\/span> *<\/span>this<\/span>;\r\n }\r\n \/\/ ....<\/span>\r\n};<\/pre>\n<\/div>\n<\/blockquote>\n<\/blockquote>\nC.66: Make move operations
noexcept<\/code><\/a><\/h3>\n<\/code><\/a>ove operations should not throw; therefore, you should declare them as noexcept. <\/span>You can implement your move constructor and move assignment operators that do not throw.
<\/span><\/p>\n\ntemplate<\/span><<\/span>typename<\/span> T><\/span>\r\nclass<\/span> Vector<\/span> {\r\n \/\/ ...<\/span>\r\n Vector(Vector&&<\/span> a) noexcept :<\/span>elem{a.elem}, sz{a.sz} { a.sz =<\/span> 0<\/span>; a.elem =<\/span> nullptr; }\r\n Vector&<\/span> operator<\/span>=<\/span>(Vector&&<\/span> a) noexcept { elem =<\/span> a.elem; sz =<\/span> a.sz; a.sz =<\/span> 0<\/span>; a.elem =<\/span> nullptr; }\r\n \/\/ ...<\/span>\r\npublic:<\/span>\r\n T*<\/span> elem;\r\n int<\/span> sz;\r\n};<\/pre>\n<\/div>\nC.67: A base class should suppress copying, and provide a virtual