Avoiding Over-Use of Namespaces

My library uses several nested namespaces, laid out like the following:

Library name
    Class name 1
    Class name 2
    Class name 3
    [...]
    Utilities
        Class name 1
            [...]
        Class name 2
            [...]
        Class name 3
            [...]
        [...]

The "Utilities" namespace contains useful extensions to each of the classes that don't warrant being included in the actual class itself.

The "Library name" namespace is necessary because it avoids broad con开发者_Python百科flicts with other libraries, the "Utilities" namespace is necessary to avoid the type of ambiguity that arises from things like this, and the "Class name" namespaces inside it avoid name clashes between utilities written for similar classes.

Despite this, it's still an enormous hassle in practice. Take the following, for example:

MyLibrary::MyContainer<int> Numbers = MyLibrary::Utilities::MyContainer::Insert(OtherContainer, 123, 456);
// Oh God, my eyes...

This makes me think I'm doing something seriously wrong. Is there an easier way to keep things organized, intuitive and unambiguous?

Look at how the standard library (or boost) is organized. Nearly all of it is inside the single std namespace. There's just little to be gained by putting everything inside its own namespace.

Boost puts most things inside boost, while major libraries get a single subnamespace (boost::mpl, or boost::filesystem, for example). And libraries commonly define a single aux subnamespace for internal implementation details.

But you don't typically see deep or fine-grained namespace hierarchies, because they're just painful to work with, and there's little to no benefit from them.

Here are some good rules of thumb:

Helper functions related to a specific class should be in the same namespace as the class, to enable ADL to work. Then you don't need to qualify the name of the helper function at all when calling it. (Like how you can call sort instead of std::sort on iterators defined in std).

For everything else, remember that the purpose of namespaces is to avoid name clashes and not much else. So all your library should be in a namespace, to avoid clashes with user code, but within that namespace, there's no technical need for further subnamespaces unless you plan to introduce clashing names.

You may want to separate internals of your library into a sub-namespace, so users don't accidentally pick them up from the main namespace, similar to Boost's aux.

But generally, I'd suggest as few nested namespaces as possible.

And finally, I tend to make a point of using short, easy-to-type and easy-to-read names for my namespaces (again, std is a good example to follow. Short and to the point, and nearly always without further nested namespaces, so you don't get a cramp from having to write it often, and so it doesn't clutter your source code too much.)

Just the first rule about helper functions and ADL would allow your example to be rewritten like this instead:

MyLibrary::MyContainer<int> Numbers = Insert(OtherContainer, 123, 456);

Then we could rename MyLibrary to, say, Lib:

Lib::MyContainer<int> Numbers = Insert(OtherContainer, 123, 456);

and you're down to something pretty manageable.

There shouldn't be any clashes between similar utility functions for different classes. C++ allows you to overload functions, and specialize templates, so that you can have both an Insert(ContainerA) and Insert(ContainerB) in the same namespace.

And of course, clashes between namespaces and classes are only possible if you actually have additional nested namespaces.

Remember that within your Library namespace, you alone dictate which names are introduced. And so you can avoid name clashes just by, well, not creating any clashing names. A namespace to separate user code from library code is important because the two may not know about each others, and so clashes can occur unintentionally.

But within your library, you can just give everything non-clashing names.

If something hurts, stop doing it. There is absolutely no need to use deeply nested namespaces in C++ - they are not intended to be architectural devices. My own code always uses a single level of namespaces.

If you insist on using nested namespaces, you can always create short aliases for them:

namespace Util = Library::Utility;

then:

int x = Util::somefunc();   // calls Library::Utility::somefunc()

A declaration in a header file necessitates the namespacing to not pollute the global namespace:

MyLibrary::Utilities::MyContainer<int> Numbers;

But in the source file you can use usings:

using namespace MyLibrary::Utilities;

...

MyContainer<int> Numbers;
Numbers.Insert(OtherContainer, 123, 456);

The fully qualified name doesn't actually look that bad to me, but I like being explicit in method and class names. But using can help things out:

You could probably get away with a using namespace MyLibrary at global scope in your source files, making it:

MyContainer<int> Numbers = Utilities::MyContainer::Insert(OtherContainer, 123, 456);

And then you can import the specific functions you need:

using MyLibrary::Utilities::MyContainer::Insert

and then MyContainer<int> Numbers = Insert(OtherContainer, 123, 456);