Is `using namespace foo;` useless?

Question

Suppose I have a library that places all its declarations in namespace foo. I can then conveniently use the library by adding:

using namespace foo;

to my source files. However, if any innocent name in foo (for example class foo::socket) is now ambiguous with global namespace names (for example ::socket()). What's more, there is no way to disambiguate them! Looks like using namespace is only useful for libraries that don't conflict with the global namespace, or am I missing something?

EDIT: by "disambiguate" I meant once for the scope, not at every use site, which is of course possible.

I guess we'll have to wait for modules for a satisfactory solution.

You can disambiguate by referencing the global namespace exactly as you showed in your question, ie, `::socket` — Donnie, May 21 '17 at 06:08
Sorry, I was unclear. I meant to disambiguate them for the rest of the scope, not at each usage (which is of course possible). If I use `foo::socket` exclusively, I want to be able to write `using namespace foo; using foo::socket;` but that doesn't work. — Avi Kivity, May 22 '17 at 10:55

score 7 · Answer 1 · edited May 23 '17 at 11:54

7

To answer your question - It is not useless, it does what you think. And in some cases (like the one I have described below, it can be an acceptable thing to do)

It can indeed make names ambiguous, you have to be very careful when importing an entire namespace, see Why is "using namespace std" considered bad practice?

I usually only import an entire namespace in the scope of something small like a function, for example

void func() {
    using namespace foo;
    // ...
}

Definitely never do it at the top of an implementation file. Not until you are absolutely sure that it will not cause any conflicts.

edited May 23 '17 at 11:54

Community

1
1

answered May 21 '17 at 05:00

Curious

20,870
8
61
146

Suppose I am sure that it will not cause conflict. The next day, the library changes, or my code changes, or I add a `#include`, and it breaks again. – Avi Kivity May 22 '17 at 10:54
Also, while importing in every function works, it causes endless repetition. Not very satisfying. – Avi Kivity May 22 '17 at 10:57
1

Until now, I never knew that we can import namespaces in the scope of a function. This was really helpful! – Still Learning Jun 10 '17 at 04:27

score 2 · Answer 2 · answered May 21 '17 at 06:07

What's more, there is no way to disambiguate them!

You are very wrong on that account. Using the fully qualified name is always allowed:

int main() {
  using namespace foo;
  foo::socket fs;
  ::socket    s; // no ambiguity
}

What you are correct about is that it does indeed may cause ambiguity very easily. So the rule of thumb is not to pull in identifiers willy-nilly. And if you need to, do it at the smallest scope required. Moreover, try to pull just the things you need. i.e:

int main() {
  using foo::reader; // not using namespace foo; for a single identifier.
  reader r;
  socket s; // no ambiguity;
}

Of course, if you need many things from the namespace, it's better to pull everything into scope, IMO.

As a side note, sometimes pulling an identifier into scope with an identical one is a good thing. Consider a possible implementation for std::iter_swap:

template<class ForwardIt1, class ForwardIt2>
void iter_swap(ForwardIt1 a, ForwardIt2 b)
{
   using std::swap;
   swap(*a, *b);
}

You may be wondering why bother with a using directive in this case, but the reason is actually better code. If the iterators point at a user defined class in namespace foo that defines a custom non-member swap function, then that function will be called after being found with argument dependent lookup.

If, on the other hand, no custom swap function is found, then std::swap will be called as a fallback. That's because the using directive makes it be a part of the candidate function set during overload resolution.

Is `using namespace foo;` useless?

2 Answers2

Linked