Question

I’ve got an argument with my colleague.

We have a class that is a member of a namespace (which is a member of the other namespace but that is not important here I think). In the header file, we nest the class block into the namespace block like this:

namespace NS {
    class A {
        void method();
        // ...
    };
}

And here is the .cpp file and the subject of our argument. I wrote:

using namespace NS;

void A::method() {
    // ...
}

The colleague told me that I use the ‘using’ directive improperly, and I should have used here the same NS { … } as in the header. (He’s modified the code and got some compiler errors that he only managed to get rid of by removing the using directive and surrounding the code with NS { … }.)

My point is that ‘using’ just affects the name lookup so A is looked for in the NS namespace, so my approach is correct, and his compiler problems were caused by something else but not by that ‘using’ directive.

Who is right and why?

Added: guys, please don’t answer like ‘I did this (or that) way many times’, that’s not much useful. We need the theory here: why this or that approach is right or wrong.

Answer 1

Your colleague is correct, you should wrap cpp with namesapce which means you define your funcitons inside namesapce NS.

namespace NS
{    
  void A::method() 
  {
    // ...
  }
}

You may get conflict name lookup if you have multiple A available.

The dangerous thing happening here is that the using declaration takes a snapshot of whatever entities named A::method in namespace NS have been seen by the time the using declaration is encountered.

Have a read of Google cpp style guilde regarding namespace, also 101 c++ coding standards