![\"mistake\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/11\/mistake.png\")
<\/p>\nThere are ten rules for overloading and overload operators in the C++ core guidelines. Many of them are pretty obvious, but your software may become very unintuitive if you don’t follow them.<\/p>\n
<\/p>\n
<\/p>\n
I’m pretty surprised to have only ten rules for overloading in the guidelines. I’m particularly surprised because I had a lot of discussions in the past about the overloading of operators in C++. Additionally, at least MISRA C++, which is heavily used in the automotive and embedded area, forbids operator overloading.<\/p>\n
In contrast to the discussion in C++, I have not a discussion in Python about operator overloading in mind, but Python is heavily based on operator overloading. To get an idea. Look at the following special functions starting and ending with two underscores, lovingly called dunder in Python. You must implement them to get a type that behaves like an int.<\/span><\/p>\n But let me continue with C++. Here are the ten rules.<\/p>\n A lot of the rules are quite obvious; therefore, I often can make it short.<\/p>\n You should follow the principle of least astonishment<\/a>. Or to say it in rule C: 61: A copy operation should copy.<\/a> That means after the assignment x = y, x == y<\/span> should hold.<\/p>\n This was obvious. Right? The following rule sounds easy, but the discussion of it is pretty enlighting.<\/p>\n<\/p>\n Implementing a symmetric operator such as + is impossible inside the class.<\/p>\n Assume that you want to implement a type MyInt. MyInt<\/span> should support addition with MyInt<\/span>‘s and built-in int<\/span>‘s. Let’s give it a try.<\/p>\n <\/p>\n <\/p>\n Because of the implicit conversion constructor (1), expression (2) is valid. In contrast, the last expression (3) is invalid because the 5<\/span> in the expression 5 + myFive<\/span> will not implicitly convert to a MyInt;<\/span> therefore, I got a compiler error.<\/p>\n Trying to compile the program will fail because int<\/span> does not have an overloaded + operator for MyInt<\/span>. <\/p>\n The minor program has a lot of issues:<\/p>\n It’s pretty easy to overcome the first issues with a non-member operator + that is in the class declared as a friend.<\/p>\n <\/p>\n <\/p>\n <\/p>\n Now, implicit conversion from int<\/span> to MyInt<\/span> kicks in, and the variable val<\/span> is private. According to rule C.164: Avoid conversion operators<\/a>, you should not use an implicit conversion constructor. By making the conversion constructor in the following example explicit, the example will break.<\/p>\n <\/p>\n <\/p>\n Thanks to the explicit conversion operator, implicit conversion from int<\/span> to MyInt<\/span> will not happen; therefore, lines (2) and (3) fail.<\/p>\n At least I followed the rule, and my operator is symmetric.<\/p>\n One obvious way to solve the original challenge is to implement two additional + operators for MyInt4<\/span>. One should take an int as left, and one should take an int as correct argument.<\/p>\n <\/p>\n This time, I can make it short. Equivalent operations should have the same name. Or the other way around. Non-equivalent operations should not have the same name.<\/p>\n Here is an example from the guidelines:<\/p>\n <\/p>\n <\/p>\n Invoking print(arg)<\/span> with an argument feels like generic programming. You do not have to care which version of print<\/span> will be used.<\/p>\n This will not hold for the three following functions because they have different names:<\/p>\n <\/p>\n <\/p>\n If non-equivalent operations have the same name, the names may be too general or wrong. This is confusing and error-prone.<\/p>\n The following rule is quite essential: C.164: Avoid conversion operators<\/a>. I already mentioned it in rule C.161. You should not use an implicit conversion constructor and – this is new – an implicit conversion operator. Why? I will write about it in the next post<\/a>.<\/p>\n <\/p>\n <\/p>\n <\/p>\n","protected":false},"excerpt":{"rendered":" There are ten rules for overloading and overload operators in the C++ core guidelines. Many of them are pretty obvious, but your software may become very unintuitive if you don’t follow them.<\/p>\n","protected":false},"author":21,"featured_media":5336,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[372],"tags":[499,501],"class_list":["post-5340","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-modern-c","tag-classes","tag-overloading"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5340","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=5340"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5340\/revisions"}],"predecessor-version":[{"id":6853,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5340\/revisions\/6853"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5336"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5340"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5340"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5340"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}![\"python\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/11\/python.png\")
<\/p>\n\n
using<\/code> for customization points<\/a><\/li>\n&<\/code> only as part of a system of smart pointers and references<\/a><\/li>\nOverloading and overloaded operators<\/h2>\n
C.160: Define operators primarily to mimic conventional usage<\/a><\/h3>\n
C.161: Use nonmember functions for symmetric operators<\/a><\/h3>\n
\n\/\/ MyInt.cpp<\/span>\r\n\r\nstruct<\/span> MyInt{\r\n MyInt(int<\/span> v):<\/span>val(v){}; \/\/ 1<\/span>\r\n MyInt operator<\/span>+<\/span>(const<\/span> MyInt&<\/span> oth) const<\/span> { \r\n return<\/span> MyInt(val +<\/span> oth.val);\r\n }\r\n int<\/span> val;\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n MyInt myFive =<\/span> MyInt(2<\/span>) +<\/span> MyInt(3<\/span>);\r\n MyInt myFive2 =<\/span> MyInt(3<\/span>) +<\/span> MyInt(2<\/span>);\r\n \r\n MyInt myTen =<\/span> myFive +<\/span> 5<\/span>; \/\/ 2<\/span>\r\n MyInt myTen2 =<\/span> 5<\/span> +<\/span> myFive; \/\/ 3 ERROR<\/span>\r\n \r\n}\r\n \r\n<\/pre>\n<\/div>\n![\"MyIntError\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/11\/MyIntError.png\")
<\/p>\n\n
\n\/\/ MyInt2.cpp<\/span>\r\n\r\nclass<\/span> MyInt2<\/span>{\r\npublic:<\/span>\r\n MyInt2(int<\/span> v):<\/span>val(v){};\r\n friend<\/span> MyInt2 operator<\/span>+<\/span>(const<\/span> MyInt2&<\/span> fir, const<\/span> MyInt2&<\/span> sec){ \r\n return<\/span> MyInt2(fir.val +<\/span> sec.val);\r\n }\r\nprivate:<\/span>\r\n int<\/span> val;\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n MyInt2 myFive =<\/span> MyInt2(2<\/span>) +<\/span> MyInt2(3<\/span>);\r\n MyInt2 myFive2 =<\/span> MyInt2(3<\/span>) +<\/span> MyInt2(2<\/span>);\r\n \r\n MyInt2 myTen =<\/span> myFive +<\/span> 5<\/span>;\r\n MyInt2 myTen2 =<\/span> 5<\/span> +<\/span> myFive; \r\n \r\n}\r\n \r\n<\/pre>\n<\/div>\n\n\/\/ MyInt3.cpp<\/span>\r\n\r\nclass<\/span> MyInt3<\/span>{\r\npublic:<\/span>\r\n explicit<\/span> MyInt3(int<\/span> v):<\/span>val(v){}; \/\/ 1<\/span>\r\n friend<\/span> MyInt3 operator<\/span>+<\/span>(const<\/span> MyInt3&<\/span> fir, const<\/span> MyInt3&<\/span> sec){ \r\n return<\/span> MyInt3(fir.val +<\/span> sec.val);\r\n }\r\nprivate:<\/span>\r\n int<\/span> val;\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n MyInt3 myFive =<\/span> MyInt3(2<\/span>) +<\/span> MyInt3(3<\/span>);\r\n MyInt3 myFive2 =<\/span> MyInt3(3<\/span>) +<\/span> MyInt3(2<\/span>);\r\n \r\n MyInt3 myTen =<\/span> myFive +<\/span> 5<\/span>; \/\/ 2<\/span>\r\n MyInt3 myTen2 =<\/span> 5<\/span> +<\/span> myFive; \/\/ 3<\/span>\r\n \r\n}\r\n<\/pre>\n<\/div>\n![\"MyInt3Error\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/11\/MyInt3Error.png\")
<\/p>\n\n\/\/ MyInt4.cpp<\/span>\r\n\r\nclass<\/span> MyInt4<\/span>{\r\npublic:<\/span>\r\n explicit<\/span> MyInt4(int<\/span> v):<\/span>val(v){}; \/\/ 1<\/span>\r\n friend<\/span> MyInt4 operator<\/span>+<\/span>(const<\/span> MyInt4&<\/span> fir, const<\/span> MyInt4&<\/span> sec){ \r\n return<\/span> MyInt4(fir.val +<\/span> sec.val);\r\n }\r\n friend<\/span> MyInt4 operator<\/span>+<\/span>(const<\/span> MyInt4&<\/span> fir, int<\/span> sec){\r\n return<\/span> MyInt4(fir.val +<\/span> sec);\r\n }\r\n friend<\/span> MyInt4 operator<\/span>+<\/span>(int<\/span> fir, const<\/span> MyInt4&<\/span> sec){\r\n return<\/span> MyInt4(fir +<\/span> sec.val);\r\n }\r\nprivate:<\/span>\r\n int<\/span> val;\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n MyInt4 myFive =<\/span> MyInt4(2<\/span>) +<\/span> MyInt4(3<\/span>);\r\n MyInt4 myFive2 =<\/span> MyInt4(3<\/span>) +<\/span> MyInt4(2<\/span>);\r\n \r\n MyInt4 myTen =<\/span> myFive +<\/span> 5<\/span>; \/\/ 2<\/span>\r\n MyInt4 myTen2 =<\/span> 5<\/span> +<\/span> myFive; \/\/ 3<\/span>\r\n \r\n}\r\n<\/pre>\n<\/div>\nC.162: Overload operations that are roughly equivalent, <\/a>and C.163: Overload only for operations that are roughly equivalent<\/a><\/h3>\n
\nvoid<\/span> print<\/span>(int<\/span> a);\r\nvoid<\/span> print<\/span>(int<\/span> a, int<\/span> base);\r\nvoid<\/span> print<\/span>(const<\/span> string&<\/span>);\r\n<\/pre>\n<\/div>\n\nvoid<\/span> print_int<\/span>(int<\/span> a);\r\nvoid<\/span> print_based<\/span>(int<\/span> a, int<\/span> base);\r\nvoid<\/span> print_string<\/span>(const<\/span> string&<\/span>);\r\n<\/pre>\n<\/div>\nWhat’s next?<\/h2>\n