It is often that I see people using namespace directives in header files. This is a bad practice maybe not enought explained, so I will try to clarify why one should always avoid this.<\/p>\n
When you are using a using directive (such as using namespace std) or using declarations (such as using std::cout) you are bringing into the current namespace (either the global one or a named one) all the entities from the specified namespace (in the case of a using directive) or the entities specified with using declarations. Header files are meant to be included in sources files (usually more that just one source file) and the order of the include statements is most likely different.
\nIf entities (types, functions, constants, etc.) with coliding names are brought into the same translation unit (source file) via different header files then the compiler will trigger errors due to ambiguities.<\/p>\n
The following example will demonstrate this aspect. Suppose that you have an own list implementation in a file called mylist.h.<\/p>\n
\r\n#pragma once \r\n\r\nnamespace mycontainers \r\n{\r\n class list\r\n {\r\n\r\n };\r\n}\r\n<\/pre>\nand you make use of this container in a class called foo, but in the header you are using a namespace directive to avoid writing the fully qualified name for list.<\/p>\n
\r\n#pragma once \r\n#include \"mylist.h\"\r\n\r\nusing namespace mycontainers;\r\n\r\nclass foo \r\n{\r\n list mylist_;\r\n};\r\n<\/pre>\nHowever, a second class, called bar, is using the STL list, and also using a namespace directive.<\/p>\n
\r\n#pragma once \r\n#include < list >\r\n\r\nusing namespace std;\r\n\r\nclass bar \r\n{\r\n list< int > mylist_;\r\n};\r\n<\/pre>\nAll good as long as you use foo and bar separatelly. But the moment you need to include them both in the same source file (maybe directly, maybe via another headers) errors arise.<\/p>\n
\r\n#include \"foo.h\"\r\n#include \"bar.h\"\r\n\r\nint main()\r\n{\r\n foo f;\r\n\r\n return 0;\r\n}\r\n<\/pre>\nHere are the errors:<\/p>\n
\r\n1>d:mariusvc++win32_testbar.h(9) : error C2872: 'list' : ambiguous symbol\r\n1> could be 'c:program filesmicrosoft visual studio 9.0vcincludelist(95) : std::list'\r\n1> or 'd:mariusvc++win32_testmylist.h(6) : mycontainers::list'\r\n1>d:mariusvc++win32_testbar.h(9) : error C2872: 'list' : ambiguous symbol\r\n1> could be 'c:program filesmicrosoft visual studio 9.0vcincludelist(95) : std::list'\r\n1> or 'd:mariusvc++win32_testmylist.h(6) : mycontainers::list'\r\n<\/pre>\nOf course, if you switch the order of #includes in you get another error:<\/p>\n
\r\n1>d:mariusvc++win32_testfoo.h(8) : error C2872: 'list' : ambiguous symbol\r\n1> could be 'd:mariusvc++win32_testmylist.h(6) : mycontainers::list'\r\n1> or 'c:program filesmicrosoft visual studio 9.0vcincludelist(95) : std::list'\r\n<\/pre>\nA second, more hard to spot error is explained by Sutter and Alexandrescu in C++ Coding Standards – 101 Rules, Guidelines, and Best Practices<\/a>.
\nWhen you make use of a using declaration (using std::list), a snapshot of the used entity is taken. All later references to this entity are based on this snapshot. They provide the following example:<\/p>\n\r\n\/\/ sample 1\r\nnamespace A\r\n{\r\n int f(double);\r\n}\r\n\r\n\/\/ sample 2\r\nnamespace B\r\n{\r\n using A::f;\r\n void g();\r\n}\r\n\r\n\/\/ sample 3\r\nnamespace A\r\n{\r\n int f(int);\r\n}\r\n\r\n\/\/ sample 4\r\nvoid B::g()\r\n{\r\n f(1);\r\n}\r\n<\/pre>\nWhen using A::f is encounted, a snapshot of A::f is taken from what was found so far. Only f(double) was declared already, f(int) is found only later.
\nSo though this later overload was a better match for f(1) it would be ignored, because it wasn’t known at the time of the using declaration.<\/p>\n
This issue complicates more if each of the first 3 samples were in different files. Then the order of the $include directives in the file that contains the 4th sample would dictate which overload of f() to be used.
\nAnd if sample 4 was itself in a header, other that the first 3, the order of the includes would become even more critical.<\/p>\n
For these reasons, you should keep in mind never to use namespace directives or declarations in a header file. Instead use the fully qualified name for the types, functions, constants, etc. that you use, and leave the using directives for the source file exclusively.<\/p>\n","protected":false},"excerpt":{"rendered":"
It is often that I see people using namespace directives in header files. This is a bad practice maybe not enought explained, so I will try to clarify why one should always avoid this. When you are using a using directive (such as using namespace std) or using declarations (such as using std::cout) you are … Read more<\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_uag_custom_page_level_css":"","advgb_blocks_editor_width":"","advgb_blocks_columns_visual_guide":"","_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"jetpack_post_was_ever_published":false},"categories":[7],"tags":[451,108,109,107],"class_list":["post-254","post","type-post","status-publish","format-standard","hentry","category-c","tag-c","tag-directives","tag-headers","tag-namespace"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t