Question

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).

Answer 1

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.