![\"genetic\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/11\/genetic.png\")
<\/p>\nI started the last post on my journey through the rules for overloading functions and operators. Let me continue and finish my journey with this post.<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
First, here are all ten rules for functions and operators.<\/p>\n
<\/p>\n
using<\/code> for customization points<\/a><\/li>\n- C.166: Overload unary
&<\/code> only as part of a system of smart pointers and references<\/a><\/li>\n- C.167: Use an operator for an operation with its conventional meaning<\/a><\/li>\n
- C.168: Define overloaded operators in the namespace of their operands<\/a><\/li>\n
- C.170: If you feel like overloading a lambda, use a generic lambda<\/a><\/li>\n<\/ul>\n
Our journey continues with rule C.164. That is quite an important rule.<\/p>\n
C.164: Avoid conversion operators<\/a><\/h3>\nIf you want fun, overload the operator bool and make it not explicit. This means that type conversion from bool<\/span> to int <\/span>can happen.<\/p>\nBut I should be serious. Let me design a class MyHouse<\/span>, which can be bought by a family; therefore, I decided to implement the operator bool to check if a family has bought the house efficiently.<\/p>\n <\/p>\n
<\/p>\n
\n\/\/ implicitConversion.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n\r\n\r\nstruct<\/span> MyHouse{\r\n MyHouse() =<\/span> default<\/span>;\r\n MyHouse(const<\/span> std::<\/span>string&<\/span> fam):<\/span> family(fam){}\r\n\t\r\n operator<\/span> bool<\/span>(){ return<\/span> not family.empty(); } \/\/ (1)<\/span>\r\n \/\/ explicit operator bool(){ return not family.empty(); } \/\/ (2)<\/span>\r\n\t\r\n std::<\/span>string family =<\/span> \"\"<\/span>;\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n\t\r\n std::<\/span>cout <<<\/span> std::<\/span>boolalpha <<<\/span> std::<\/span>endl;\r\n\t\r\n MyHouse firstHouse;\r\n if<\/span> (not firstHouse){ \/\/ (3)<\/span>\r\n std::<\/span>cout <<<\/span> \"firstHouse is already sold.\"<\/span> <<<\/span> std::<\/span>endl;\r\n };\r\n\t\r\n MyHouse secondHouse(\"grimm\"<\/span>); \/\/ (4)<\/span>\r\n if<\/span> (secondHouse){\r\n std::<\/span>cout <<<\/span> \"Grimm bought secondHouse.\"<\/span> <<<\/span> std::<\/span>endl;\r\n }\r\n\t\r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\t\r\n int<\/span> myNewHouse =<\/span> firstHouse +<\/span> secondHouse; \/\/ (5)<\/span>\r\n auto<\/span> myNewHouse2 =<\/span> (20<\/span> *<\/span> firstHouse -<\/span> 10<\/span> *<\/span> secondHouse) \/<\/span> secondHouse;\r\n\r\n std::<\/span>cout <<<\/span> \"myNewHouse: \"<\/span> <<<\/span> myNewHouse <<<\/span> std::<\/span>endl;\r\n std::<\/span>cout <<<\/span> \"myNewHouse2: \"<\/span> <<<\/span> myNewHouse2 <<<\/span> std::<\/span>endl;\r\n\t\r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
Now, I can quickly check with the operator bool (1) if a family (4) or no family (3) lives in the house. Fine. But due to the implicit operator bool, I can use my house in arithmetic expressions (5). That was not my intention.<\/p>\n
![\"implicitConversion\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/11\/implicitConversion.png\")
<\/p>\n
This is weird. Since C++11, you can make conversion operators explicit; therefore, no implicit conversion to int<\/span> will kick in. I have to make the operator bool explicit (2), and adding houses is not possible anymore, but I can use a house in logical expressions. <\/p>\nNow, the compilation of the program fails.<\/p>\n
![\"implicitConversionError\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/11\/implicitConversionError.png\")
<\/p>\n<\/p>\n
C.165: Use using<\/code> for customization points<\/a><\/h3>\nThis rule is quite unique; therefore, I will make it short. There are about 50 overloads for std::swap<\/a> available in the C++ standard. It’s pretty probable that you already implemented swap for your own type: C++ Core Guidelines: Comparison, Swap, and Hash<\/a>.<\/p>\n <\/p>\n
<\/p>\n
\nnamespace<\/span> N {\r\n My_type X { \/* ... *\/<\/span> };\r\n void<\/span> swap<\/span>(X&<\/span>, X&<\/span>); \/\/ optimized swap for N::X<\/span>\r\n \/\/ ...<\/span>\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
Because of argument-dependent lookup (see C.168), the compiler will find your swap implementation. Using the generic std::swap as a kind of fallback is a good idea. std::swap<\/span> maybe not be optimized for your data type, but at least it works. You can achieve that by introducing the function std::swap<\/span>.<\/p>\n<\/p>\n
\nvoid<\/span> f3<\/span>(N::<\/span>X&<\/span> a, N::<\/span>X&<\/span> b)\r\n{\r\n using<\/span> std::<\/span>swap; \/\/ make std::swap available<\/span>\r\n swap(a, b); \/\/ calls N::swap if it exists, otherwise std::swap<\/span>\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
C.166: Overload unary &<\/code> only as part of a system of smart pointers and references<\/a><\/h3>\nHonestly, this rule is way too special to write about in this post. If you want to create a proxy by overloading the unary operator &, you should know the consequences.<\/p>\n
C.167: Use an operator for an operation with its conventional meaning<\/a><\/h3>\nThis rule is similar to rule C.160: Define operators primarily to mimic conventional usage. I referred to it in my last post: C++ Core Guidelines: Rules for Overloading and Overload Operators<\/a>.<\/p>\nThis rule applies to a lot of operators.<\/p>\n
\n- <<, >><\/span>: input and output<\/li>\n
==<\/code>, !=<\/code>, <<\/code>, <=<\/code>, ><\/code>, <\/span>and <\/span>>=<\/code><\/span>: comparison<\/li>\n+<\/code>, -<\/code>, *<\/code>, \/<\/code>, <\/span>and<\/span> %<\/code><\/span>: arithmetic<\/li>\n.<\/code>, -><\/code>, <\/span>unary <\/span>*<\/code>, <\/span>and <\/span>[]<\/code><\/span>: access<\/li>\n=<\/code>: assignment<\/li>\n<\/ul>\nC.168: Define overloaded operators in the namespace of their operands<\/a><\/h3>\nADL is a special property in C++, making our life as a programmer easier. ADL stands for argument-dependent lookup. Sometimes it is called Koenig lookup. It means that for unqualified<\/strong> function calls, the functions in the namespace of the function arguments are considered by the C++ runtime. For more details about ADL, read here: argument-dependent lookup.<\/a><\/p>\nOnly to remind you and give you a short example: because of ADL, the C++ runtime will find the right operator == in the namespace of the operands.<\/p>\n
<\/p>\n
<\/p>\n
\nnamespace<\/span> N {\r\n struct<\/span> S { };\r\n bool<\/span> operator<\/span>==<\/span>(S, S); \/\/ OK: in the same namespace as S, and even next to S<\/span>\r\n}\r\n\r\nN::<\/span>S s;\r\n\r\nbool<\/span> x =<\/span> (s ==<\/span> s); \/\/ finds N::operator==() by ADL<\/span>\r\n<\/pre>\n<\/div>\nC.170: If you feel like overloading a lambda, use a generic lambda<\/a><\/h3>\nThis rule is relatively easy to get. You can not overload a lambda. With C++14, you can overcome this restriction by implementing a generic lambda.<\/p>\n
<\/p>\n
\nauto<\/span> g =<\/span> [](int<\/span>) { \/* ... *\/<\/span> };\r\nauto<\/span> g =<\/span> [](double<\/span>) { \/* ... *\/<\/span> }; \/\/ error: cannot overload lambdas<\/span>\r\n\r\nauto<\/span> h =<\/span> [](auto<\/span>) { \/* ... *\/<\/span> }; \/\/ OK<\/span>\r\n<\/pre>\n<\/div>\n <\/p>\n
Maybe you know it. A lambda is just an instance of a class for which the call operator is overloaded, or to say in other words, a function object<\/a>. In addition, a generic lambda is a function object with a templatized call operator. That’s all.<\/p>\nWhat’s next?<\/h2>\n
There are four rules for the particular class type union. I’m unsure if I will dedicate the next post<\/a> to unions. Afterward, I’m done with classes and class hierarchies and will write about enumerations.<\/p>\n