![\"GeneralIdioms\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2022\/12\/GeneralIdioms.png\")
<\/p>\nArgument-Dependent Lookup (ADL), also known as Koenig Lookup, is a set of “magical” rules for the lookup of unqualified functions based on their function arguments.<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
The Hidden Friend Idiom is based on Argument-Dependent Lookup (ADL). Therefore, let’s start this post with ADL.<\/p>\n
Have you ever wondered why the following program works?<\/p>\n
<\/p>\n
#include <iostream><\/span>\r\n\r\nint<\/span> main<\/span>() {\r\n std::<\/span>cout <<<\/span> \"Hello world<\/span>\";\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
Why should the program not work? The overloaded output operator operator<<<\/code> is defined in the std<\/code> namespace. The question is, therefore: How is the appropriate overloaded output operator for std::string<\/code> found? You may already assume it.<\/p>\nWikipedia has a nice definition of ADL:<\/p>\n
\n- Argument-Dependent Lookup<\/strong>: In the C++ programming language, argument-dependent lookup<\/b> (ADL<\/b>), or argument-dependent name lookup<\/b>, applies to the lookup of an unqualified function name depending on the types of the arguments given to the function call. This behavior is also known as Koenig lookup<\/b>, as it is often attributed to Andrew Koenig<\/a>, though he is not its inventor.(https:\/\/en.wikipedia.org\/wiki\/Argument-dependent_name_lookup<\/a>)<\/li>\n<\/ul>\n
Let’s analyze this. Here is a simple example of applying ADL:<\/p>\n
<\/p>\n
\n\/\/ adl.cpp<\/span>\r\n\r\nnamespace<\/span> MyNamespace {\r\n struct<\/span> MyStruct {};\r\n void<\/span> function<\/span>(MyStruct) {}\r\n} \r\n\r\nint<\/span> main() {\r\n\r\n MyNamespace::<\/span>MyStruct obj; \r\n function(obj); \/\/ (1)<\/span>\r\n\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
The call function(obj)<\/code> in line (1) would fail without Argument-Dependent Lookup. Thanks to ADL, the lookup for unqualified function names includes the namespace of their arguments in addition to the usual unqualified name lookup<\/a>. Consequentially, the name function is found in the namespace MyNamespace<\/code>.<\/p>\nNow, we know what ADL means. But this does not solve our original challenge. Why does the simple “Hello World” program work?<\/p>\n
<\/p>\n
\n#include <iostream><\/span>\r\n\r\nint<\/span> main<\/span>() {\r\n std::<\/span>cout <<<\/span> \"Hello world<\/span>\";\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
Let’s try it out with C++ Insights:https:\/\/cppinsights.io\/s\/bfb25e37<\/a><\/p>\n<\/p>\n
\n#include <iostream><\/span>\r\n\r\nint<\/span> main<\/span>()\r\n{\r\n std::<\/span>operator<\/span><<<\/span>(std::<\/span>cout, \"Hello world\"<\/span>); \/\/ (1)<\/span>\r\n return<\/span> 0<\/span>;\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
The call std::cout << \"Hello world\";<\/code> is equivalent to the function call operator<<(std::cout, \"Hello world\"); <\/code>(line 1). <\/code>ADL regards the namespace of its arguments that includes in our concrete case std::cout. <\/code><\/p>\nFinally, let me write about the Hidden Friend Idiom.<\/p>\n
<\/p>\n
Hidden Friend Idiom<\/h2>\n
Argument-Dependend Lookup extends the public interface of a class: non-member functions or non-member operators extend the public interface of that class. Now, the Hidden Friend Idiom kicks in:<\/p>\n
Friend functions or operators defined inside the class have two special properties:<\/p>\n
\n- They can access the private members of the class.<\/li>\n
- They are non-member functions or operators.<\/li>\n<\/ol>\n
The second point is pretty unknown, and I regularly have to explain it when I give a class. A friend<\/code> function defined inside the class has interesting consequences for the overloading of operators. Friend operators defined inside the class can access the private members of the class, are non-member functions, and are found by Argument-Dependent Lookup.<\/p>\n <\/p>\n
<\/p>\n
\n\/\/ hiddenFriend.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\nclass<\/span> MyDistance<\/span>{\r\n public:<\/span>\r\n explicit<\/span> MyDistance(double<\/span> i):<\/span>m(i){}\r\n\r\n friend<\/span> MyDistance operator<\/span> +<\/span>(const<\/span> MyDistance&<\/span> a, const<\/span> MyDistance&<\/span> b){ \/\/ (1)<\/span><\/em>\r\n return<\/span> MyDistance(a.m +<\/span> b.m);\r\n }\r\n \r\n friend<\/span> MyDistance operator<\/span> -<\/span>(const<\/span> MyDistance&<\/span> a, const<\/span> MyDistance&<\/span> b){ \/\/ (2)<\/span><\/em>\r\n return<\/span> MyDistance(a.m -<\/span> b.m);\r\n }\r\n\r\n friend<\/span> std::<\/span>ostream&<\/span> operator<\/span><<<\/span> (std::<\/span>ostream &<\/span>out, const<\/span> MyDistance&<\/span> myDist){ \/\/ (3)<\/span><\/em>\r\n out <<<\/span> myDist.m <<<\/span> \" m\"<\/span>;\r\n return<\/span> out;\r\n }\r\n \r\n private:<\/span>\r\n double<\/span> m;\r\n\r\n};\r\n\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n std::<\/span>cout <<<\/span> \"MyDistance(5.5) + MyDistance(5.5): \"<\/span> <<<\/span> MyDistance(5.5<\/span>) +<\/span> MyDistance(5.5<\/span>) <<<\/span> '\\n'<\/span>; \/\/ (4)<\/span><\/em>\r\n\r\n std::<\/span>cout <<<\/span> \"MyDistance(5.5) - MyDistance(5.5): \"<\/span> <<<\/span> MyDistance(5.5<\/span>) -<\/span> MyDistance(5.5<\/span>) <<<\/span> '\\n'<\/span>; \/\/ (5)<\/span><\/em>\r\n\r\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
All three operators in lines (1), (2), and (3) are friends. The corresponding operators (+<\/code>) in line (4) and (-<\/code>) in line (5) are found as expected.<\/p>\nC++ Insights shows once more the magic of operator overloading: https:\/\/cppinsights.io\/s\/50aae5ed<\/a><\/p>\nIn particular, the addition in line (4) (MyDistance(5.5) + MyDistance(5.5)<\/code>) is transformed into: operator+(MyDistance(5.5), MyDistance(5.5)).<\/code><\/p>\nFinally, here is the output of the program:<\/p>\n
![\"hiddenFriend\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2023\/01\/hiddenFriend.png\")
<\/p>\n
On the contrary, let me remove the friend declaration from the overloaded+<\/code> operator.<\/p>\n <\/p>\n
<\/p>\n
\nclass<\/span> MyDistance<\/span>{\r\n public:<\/span>\r\n explicit<\/span> MyDistance(double<\/span> i):<\/span>m(i){}\r\n\r\n MyDistance operator<\/span> +<\/span>(const<\/span> MyDistance&<\/span> a, const<\/span> MyDistance&<\/span> b){ \r\n return<\/span> MyDistance(a.m +<\/span> b.m);\r\n }\r\n \r\n friend<\/span> MyDistance operator<\/span> -<\/span>(const<\/span> MyDistance&<\/span> a, const<\/span> MyDistance&<\/span> b){ \r\n return<\/span> MyDistance(a.m -<\/span> b.m);\r\n }\r\n\r\n friend<\/span> std::<\/span>ostream&<\/span> operator<\/span><<<\/span> (std::<\/span>ostream &<\/span>out, const<\/span> MyDistance&<\/span> myDist){ \r\n out <<<\/span> myDist.m <<<\/span> \" m\"<\/span>;\r\n return<\/span> out;\r\n }\r\n \r\n private:<\/span>\r\n double<\/span> m;\r\n\r\n};\r\n<\/pre>\n<\/div>\n <\/p>\n
Now, the compilation fails:<\/p>\n
![\"hiddenFriendBroken\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2023\/01\/hiddenFriendBroken.png\")
<\/p>\n
<\/p>\n
The compiler essentially complains in the first line that the definition of the operator+<\/code> can only have zero or one argument (hiddenFriend:9:16<\/code>). Without the friend declaration, the operator+<\/code> is a member function, and as such, it has an implicit this<\/code> <\/a>pointer. This means that the operator+<\/code> has in sum three arguments. That is not valid c++. Consequentially, the compiler does not find the appropriate operator+<\/code> (hiddenFriend:32:75<\/code>).<\/p>\nWhat’s Next?<\/h2>\n
In addition to the Hidden Friend Idiom, C++ has many more idioms for class design. In my next post, I will write about the Rule of Zero, Five, or Six.<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n","protected":false},"excerpt":{"rendered":"
Argument-Dependent Lookup (ADL), also known as Koenig Lookup, is a set of “magical” rules for the lookup of unqualified functions based on their function arguments.<\/p>\n","protected":false},"author":21,"featured_media":6493,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[379],"tags":[],"class_list":["post-6498","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-patterns"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6498","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=6498"}],"version-history":[{"count":0,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6498\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/6493"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=6498"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=6498"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=6498"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}