When to import names into the global namespace? (using x::y, from x import y etc.)

Question

I've been programming in various languages for about 10 years now. And I still haven't figured out when it is a good idea to import something into the global namespace (using x::y in C++, from x import y in Python etc.), so I hardly ever do it.

It almost always seems like a bad idea to me, if only because it limits the set of variable names I can use. For example: Where I to use using namespace std; or using std::string;in C++, I couldn't use stringas a variable name anymore, which I occasionally do (e.g. for string utility functions).

But I'm wondering: Are there some situations where importing a name into the global namespace really makes sense? Any rules of thumb?

Answer 1

In C++, it's generally frowned upon- especially using namespace std. That std namespace has so many names, many of which are very generic algorithms, you can get some extremely nasty surprises when using namespace std. Something like using std::cout; isn't so bad. But never, ever, using anything into the global namespace in a header file. That's a firing-squad offence.

Answer 2

You should do it when it simplifies your code. You shouldn't do it when it would cause naming conflicts, or when it could be later brought into scopes where it would cause naming conflicts, such as a header file.

Some people think it should be rare. I think (outside of header files) not using it should be rare, because the namespace prefix doesn't generally add any useful information, like using someone's full name every single time you address them.

Let me put it this way. When you see string as a class name, do you automatically think std::string or mycustom::string? It's like the old adage. When you hear the sound of hooves, you think horses, not zebras. In other words, using namespace std is almost always no big deal. using namespace mycustom is likewise usually not a big deal, unless it contains a conflict with std, in which case your custom namespace is the one you want to always require the prefix for.

Answer 3

Working in Python, I use from x import y (as z) constantly, to have clear, concise names to reference imports.

From imports are invaluable in a codebase with a deep namespace hierarchy. This is especially so when the style standard for the codebase is PEP 8, which limits line length to under 80 characters.

For example, consider:

import foo

foo.bar.baz.baf.perform_task(foo.bar.baz.quux.SOME_CONSTANT, foo.bar.alice.bob.preferred_hash_function, '42', foo.bar.magic_numbers.MY_SALT)

Which could instead be written:

from foo.bar import baf
from foo.bar.alice import bob
from foo.bar.baz.quux import SOME_CONSTANT
from foo.bar.magic_numbers import MY_SALT

baf.perform_task(SOME_CONSTANT, bob.preferred_hash_function, '42', MY_SALT)

Since Python identifiers are case-sensitive and unlimited in length, we won't run out of names regardless of how many we import.

If we want to use the same name in our module as one of the modules we wish to import, we can use an alias for the import:

from foo.bar.alice import bob as carol

def bob(x, y):
    print "running bob function"
    return carol(x, y, 42)

Answer 4

It's up to programmer when to use it. IMHO it's better not use them at all, especially in header files. But there are several cases when I use it

• When I want to introduce something to another namespace e.g.

  namespace cg
  {
    namespace details
    {
      //lots of stuff
      void some_cool_foo()
      {
        //uses a lot stuff from details, here because I don't want prefix everything with details::
      }
    }
    using details::some_cool_foo;
  }
  

• To enable ADL for some algorithms from another namespace

  namespace n1
  {
  //some general foo
  }
  namespace n2
  {
    using n1::foo;
  //some struct
  }
  namespace n3
  {
    using n1::foo;
  //some struct
  }
  

If I don't want write long names of namespaces at .cpp I can always make alias

namespace bl = boost::lambda;
namespace fs = boost::filesystem;