Best practices: using namespace or reopen namespace?
c++, coding-style
Solution
I think the cleanest way is re-opening the namespace, and I've got the arguments to support it:
- with your second option, with the `using` directive, it isn't clear that you're implementing a method in that namespace. You could as well be implementing a free function that uses something from the namespace.
- the third option is usually used for implementing class member functions. If you look directly in the `cpp` file, it isn't clear that you're implementing a function from a namespace unless you know that namespace exists. The first thing that comes to mind is that you're implementing a class member function.
- the first one is the clearest. You open the namespace and define a function inside it. The function is part of the namespace, and this is the implementation.
Problem
Assume I've declared a function (or class, doesn't matter) in a header file, which is part of namespace foo: ``` namespace foo { void bar(); … } ``` For a long time I've been reopening the namespace when I was defining the function in a cpp file: ``` namespace foo { void bar() { doSomething(); … } } ``` That is because I learned it this way and it was used in a project I was working on. I never really though about it until recently, when I stumbled upon a project which used the using directive instead: ``` using namespace foo; void bar() { doSomething(); … } ``` Finally there's an option of using the full name. I find it pretty tedious, especially when classes with a lot of members are involved. In my opinion it doesn't make much sense when all content of the file is a part of one namespace. ``` void foo::bar() { doSomething(); … } ``` So my question is which one should be preferred and why? Especially regarding the first two options (using directive vs. reopen namespace).