![\"scales](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/09\/scales-310962_640.png\")
<\/p>\nThis post will be about comparisons, swap, and hash. That means I conclude with his post my treatise about default operations rules in C++.<\/p>\n
<\/p>\n
<\/p>\n
Here are the nine rules.<\/p>\n
=default<\/code> if you have to be explicit about using the default semantics<\/a><\/li>\n- C.81: Use
=delete<\/code> when you want to disable default behavior (without wanting an alternative)<\/a><\/li>\n- C.82: Don\u2019t call virtual functions in constructors and destructors<\/a><\/li>\n
- C.83: For value-like types, consider providing a
noexcept<\/code> swap function<\/a><\/li>\n- C.84: A
swap<\/code> may not fail<\/a><\/li>\n- C.85: Make
swap<\/code> noexcept<\/code><\/a><\/li>\n- C.86: Make
==<\/code> symmetric with respect of operand types and noexcept<\/code><\/a><\/li>\n- C.87: Beware of
==<\/code> on base classes<\/a><\/li>\n- C.89: Make a
hash<\/code> noexcept<\/code><\/a><\/li>\n<\/ul>\n <\/p>\n
Let’s dive into the details.<\/p>\n
Default operation rules:<\/h2>\nC.80: Use =default<\/code> if you have to be explicit about using the default semantics<\/a><\/h3>\nDo you remember the rule of five<\/a>? It means if you define one of the five special member functions, you must define all.<\/p>\nHere is the point.<\/p>\n
When I implement the destructor, such as in the following example, I have to define the copy and move constructor and assignment operator.<\/p>\n
<\/p>\n
\nclass<\/span> Tracer<\/span> {\r\n string message;\r\npublic:<\/span>\r\n Tracer(const<\/span> string&<\/span> m) :<\/span> message{m} { cerr <<<\/span> \"entering \"<\/span> <<<\/span> message <<<\/span> '\\n'<\/span>; }\r\n ~<\/span>Tracer() { cerr <<<\/span> \"exiting \"<\/span> <<<\/span> message <<<\/span> '\\n'<\/span>; }\r\n\r\n Tracer(const<\/span> Tracer&<\/span>) =<\/span> default<\/span>;\r\n Tracer&<\/span> operator<\/span>=<\/span>(const<\/span> Tracer&<\/span>) =<\/span> default<\/span>;\r\n Tracer(Tracer&&<\/span>) =<\/span> default<\/span>;\r\n Tracer&<\/span> operator<\/span>=<\/span>(Tracer&&<\/span>) =<\/span> default<\/span>;\r\n};\r\n<\/pre>\n<\/div>\n <\/p>\n
That was easy! Right? But I can also do it alone, which is at least uninteresting and error-prone. <\/p>\n
<\/p>\n
<\/p>\n
\nclass<\/span> Tracer2<\/span> {\r\n string message;\r\npublic:<\/span>\r\n Tracer2(const<\/span> string&<\/span> m) :<\/span> message{m} { cerr <<<\/span> \"entering \"<\/span> <<<\/span> message <<<\/span> '\\n'<\/span>; }\r\n ~<\/span>Tracer2() { cerr <<<\/span> \"exiting \"<\/span> <<<\/span> message <<<\/span> '\\n'<\/span>; }\r\n\r\n Tracer2(const<\/span> Tracer2&<\/span> a) :<\/span> message{a.message} {}\r\n Tracer2&<\/span> operator<\/span>=<\/span>(const<\/span> Tracer2&<\/span> a) { message =<\/span> a.message; return<\/span> *<\/span>this<\/span>; }\r\n Tracer2(Tracer2&&<\/span> a) :<\/span>message{a.message} {}\r\n Tracer2&<\/span> operator<\/span>=<\/span>(Tracer2&&<\/span> a) { message =<\/span> a.message; return<\/span> *<\/span>this<\/span>; }\r\n};\r\n<\/pre>\n<\/div>\n <\/p>\n<\/p>\n
C.81: Use =delete<\/code> when you want to disable default behavior (without wanting an alternative)<\/a><\/h3>\nSometimes, you want to disable the default operations. Here comes delete<\/span> into the play. C++ eats its own dog food. The copy constructor of types such as locks, mutexes, promises, or futures is set to delete. <\/span>The same holds true for the smart pointer std::unique_ptr: std::unique_ptr(const std::unique_ptr&) = delete.
<\/span><\/p>\nYou can use delete to create strange types. Instances of Immortal<\/span> cannot be destroyed.<\/p>\n<\/p>\n
\nclass<\/span> Immortal<\/span> {\r\npublic:<\/span>\r\n ~<\/span>Immortal() =<\/span> delete<\/span>; \/\/ do not allow destruction<\/span>\r\n \/\/ ...<\/span>\r\n};\r\n\r\nvoid<\/span> use<\/span>()\r\n{\r\n Immortal ugh; \/\/ error: ugh cannot be destroyed<\/span>\r\n Immortal*<\/span> p =<\/span> new<\/span> Immortal{};\r\n delete<\/span> p; \/\/ error: cannot destroy *p<\/span>\r\n}\r\n<\/pre>\n<\/div>\nC.82: Don\u2019t call virtual functions in constructors and destructors<\/a><\/h3>\nThis rule is quite similar to rule C.50: Use a factory function if you need \u201cvirtual behavior\u201d during initialization<\/a> which I presented in the post C++ Core Guidelines: Constructors<\/a>.<\/p>\nThe next three rules are about swap<\/span> functions. Let’s do it together.<\/p>\nC.83: For value-like types, consider providing a noexcept<\/code> swap function, <\/a>C.84: A swap<\/code> may not fail, and <\/a>C.85: Make swap<\/code> noexcept<\/code><\/a><\/h3>\nA swap function is quite handy.<\/p>\n
<\/p>\n
\ntemplate<\/span><<\/span> typename<\/span> T ><\/span>\r\nvoid<\/span> std::<\/span>swap(T &<\/span> a, T &<\/span> b) noexcept {\r\n T tmp(std::<\/span>move(a));\r\n a =<\/span> std::<\/span>move(b);\r\n b =<\/span> std::<\/span>move(tmp);\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
The C++ standard offers more than 40 specializations for std::swap<\/a>. You can use it as a building block for many idioms, such as copy construction\/assignment. A swap function should not fail; therefore, you must declare it as noexcept.<\/span><\/p>\nHere is an example of a move assignment operation using std::swap<\/span>. pdata<\/span> points to an array.<\/p>\n<\/p>\n
\nclass<\/span> Cont<\/span>{ \r\npublic:<\/span>\r\n Cont&<\/span> operator<\/span>=<\/span>(Cont&&<\/span> rhs);\r\n \r\nprivate:<\/span>\r\n int<\/span> *<\/span>pData; <\/span>\r\n};\r\n\r\nCont&<\/span> Cont::<\/span>operator<\/span>=<\/span>(Cont&&<\/span> rhs){\r\n std::<\/span>swap(pData, rhs.pData);\r\n return<\/span> *<\/span>this<\/span>;\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
C.86: Make ==<\/code> symmetric with respect of operand types and noexcept<\/code><\/a><\/h3>\nIf you don’t want to surprise your user, you should make the == operato<\/span>r symmetric.<\/p>\nHere is an unintuitive == operator<\/span>, which is defined inside the class.<\/p>\n<\/p>\n
\nclass<\/span> MyNumber<\/span> {\r\n int<\/span> num;\r\npublic:<\/span>\r\n MyNumber(int<\/span> n):<\/span> num(n){};\r\n bool<\/span> operator<\/span>==<\/span>(const<\/span> MyNumber&<\/span> rhs) const { return<\/span> num ==<\/span> rhs.num; }\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n<\/span><\/span><\/span> <\/span><\/span><\/span>MyNumber(5<\/span>) ==<\/span> 5<\/span>;\r\n \/\/ 5 == MyNumber(5);<\/span>\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
The call MyNumber(5) == 5<\/span> is valid because the constructor converts the int<\/span> argument to an instance of MyNumber. <\/span>The last line gives an error. The comparison operator for natural numbers will not accept an instance of MyNumber<\/span>.<\/p>\nThe elegant way to solve this asymmetry is to declare a friend operator==<\/code> inside the class MyNumber.<\/span> <\/span>Here is the second version of MyNumber.<\/span><\/p>\n<\/p>\n
\nclass<\/span> MyNumber<\/span> {\r\n int<\/span> num;\r\npublic:<\/span>\r\n MyNumber(int<\/span> n):<\/span> num(n){};\r\n bool<\/span>