{"id":336,"date":"2018-02-14T06:50:37","date_gmt":"2018-02-14T06:50:37","guid":{"rendered":"http:\/\/cppdepend.com\/blog\/?p=336"},"modified":"2018-11-09T18:32:57","modified_gmt":"2018-11-09T18:32:57","slug":"7-common-reasons-of-using-the-namespaces-in-a-c-project","status":"publish","type":"post","link":"https:\/\/cppdepend.com\/blog\/7-common-reasons-of-using-the-namespaces-in-a-c-project\/","title":{"rendered":"7 Common reasons of using the namespaces in a C++ project."},"content":{"rendered":"

Namespaces were introduced to the C++ Standard in 1995\u00a0and usually they are defined like this:<\/p>\n

A namespace defines a new scope. They provide a way to avoid name collisions.<\/p><\/blockquote>\n

Although namespaces are used extensively in recent C++ code, most older code does not use this facility.\u00a0<\/span><\/p>\n

After exploring the source code of many C++ projects, here are some common reasons of using the namespaces in these projects.<\/p>\n

1- Avoid\u00a0name collisions.<\/h2>\n

In this case their use are\u00a0just useful for the compiler, no added value for the developer to make the code more readable and maintainable.<\/p>\n

2- Modularize the\u00a0code<\/strong><\/h2>\n

Modern C++ libraries use extensively the namespaces to modularize their code base, and they use the \u00a0\u201cNamespace-by-feature\u201d approach.\u00a0Namespace-by-feature uses namespaces\u00a0to reflect the feature set. It places all items related to a single feature (and only that feature) into a single namespace. This results in namespaces\u00a0with high cohesion and high modularity, and with minimal coupling between namespaces. Items that work closely together are placed next to each other.<\/p>\n

Boost is the best example of grouping by feature, it contains thousands of namespaces, each one is used to group a specific feature.<\/p>\n

3- Anonymous namespace.<\/strong><\/h2>\n

Namespace with no name avoids making global static variable. The \u201canonymous\u201d namespace you have created will only be accessible within the file you created it in.<\/p>\n

4- workarround of the enum issue.<\/h2>\n

\u201cTraditional\u201d enums in C++ export their enumerators in the surrounding scope ,which can lead to name collisions, if two different enums in the same have scope define enumerators with the same name,<\/p>\n

In a large project, you would not be guaranteed that two distinct enums don\u2019t both called with the same name. This issue was resolved in C++11, using\u00a0\u00a0enum class<\/strong>\u00a0which will implicitly scope the enum values within the enum\u2019s name.<\/p>\n

Many years ago the trick of declaring an enum inside a namespace is used, for example instead of declaring an enum like this<\/p>\n

enum<\/span> status<\/span>{<\/span>\r\n  status_ok<\/span>,<\/span>\r\n  status_error\r\n<\/span>};<\/span><\/code><\/pre>\n
it\u2019s declared inside an namespace:<\/p>\n
namespace<\/span> status<\/span>{\r\n<\/span>       enum<\/span> status<\/span>{<\/span>\r\n         ok<\/span>,<\/span>\r\n          error\r\n  <\/span>};\r\n<\/span>}<\/span><\/code><\/pre>\n
Many C++ projects use this trick, for example the Unreal Engine source code use widely this technique.<\/p>\n
[adrotate banner=”3″]<\/p>\n
5- Hiding details by convention<\/strong><\/h2>\n
For templated libraries where the code is implemented in header files, it\u2019s\u00a0interesting to find a way to inform the library user that he do not need to use directly some specific types because they concern only the implementation.\u00a0In\u00a0C# the \u201cinternal\u201d keyword did the job, but in C++ there\u2019s no way to hide public types to the library user.<\/p>\n
A common idiom in modern C++, pioneered by the developers of the Boost libraries, is to separate symbols that form part of the implementation of your module (that is, don\u2019t form part of the public API) but that have to be publicly available into a separate sub-namespace, by convention named detail.<\/p>\n
For example in the boost::math documentation, it\u2019s specified that:<\/p>\n
Functions not intended for use by applications are in\u00a0boost<\/span>::<\/span>math<\/span>::<\/span>detail<\/span><\/code>.<\/p><\/blockquote>\n
\n
\n
And the inline namespaces provided by C++11 brings two other possibilities:<\/h2>\n
\n
When an inline namespace is defined, a\u00a0using<\/samp>\u00a0directive is implicitly inserted into its enclosing namespace. While looking up a qualified name through the enclosing namespace, members of the inline namespace are brought in and found by the implicit\u00a0using<\/samp>\u00a0directive, even if that name is declared in the enclosing namespace.<\/p>\n
\n
For example, if you compile the following code with USE_INLINE_B defined, the output of the resulting executable is 1; otherwise, the output is 2.<\/p>\n
namespace A {\r\n#if USE_INLINE_B\r\n\u00a0\u00a0 inline\r\n#endif\r\n\u00a0\u00a0 namespace B {\r\n\u00a0\u00a0\u00a0\u00a0\u00a0 int foo(bool) { return 1; }\r\n\u00a0\u00a0 }\r\n\u00a0\u00a0 int foo(int) { return 2; }\r\n}\r\n\r\nint main(void) {\r\n\u00a0\u00a0 return A::foo(true);\r\n}<\/pre>\n<\/div>\n
Here are the two other possibilities of using the inline namespaces as explained in\u00a0this document<\/a>.<\/p>\n
[adrotate banner=”3″]<\/p>\n
6-Using inline namespace definitions in explicit instantiation and specialization<\/h2>\n
You can explicitly instantiate or specialize each member of an inline namespace as if it were a member of its enclosing namespace. Name lookup for the primary template of an explicit instantiation or specialization in a namespace, for example M, considers the inline namespaces whose enclosing namespace set includes M. For example:<\/p>\n
namespace L {\r\n   inline namespace M {\r\n       template <typename T> class C; \r\n   }\r\n\r\n   template <typename T> void f(T) { \/*...*\/ };\r\n}\r\n\r\nstruct X { \/*...*\/ };\r\nnamespace L {\r\n  template<> class C<X> { \/*...*\/ };    \/\/template specialization\r\n}\r\n\r\nint main()\r\n{\r\n  L::C<X> r;\r\n  f(r);  \/\/ fine, L is an associated namespace of C\r\n}<\/pre>\n
In this example,\u00a0M<\/samp>\u00a0is an inline namespace of its enclosing namespace\u00a0L<\/samp>, class\u00a0C<\/samp>\u00a0is a member of inline namespace\u00a0M<\/samp>, so\u00a0L<\/samp>\u00a0is an associated namespace of class\u00a0C<\/samp>.<\/p>\n<\/div>\n
\n
The following rules apply when you use inline namespace definitions in explicit instantiation and specialization:<\/p>\n