What and how to use namespaces in C++

Namespaces (name spaces) in C++ are a fundamental tool for code organization. They allow grouping under the same name functions, classes, variables, and other related programming elements.

Namespaces help us avoid name conflicts. Imagine you have two different libraries that define a class called Client. Without namespaces, this would result in a conflict and ambiguity. With namespaces, we can encapsulate each Client in its own namespace (thus avoiding any conflict).

Creating a namespace in C++

Creating a namespace in C++ is done by declaring the keyword namespace, followed by the namespace name and a block of braces that contains the definitions of classes and other elements.

namespace MyNamespace {
    class MyClass {
        // Class code
    };
}

In this example, MyNamespace is the namespace that contains the definition of MyClass.

Using namespaces

To use a namespace in a C++ program, you can do it in two ways:

Using the full name of the type

When using the full name of a type, we include the namespace before the type name (this is called full qualified).

For example, if we have a namespace called MyProgram and a class called MyClass, we can use it as follows:

MyProgram::MyClass myObject;

Importing the namespace

Another way to use a namespace is importing it with the using directive. This allows us to directly use the type name without having to specify the full namespace.

using namespace MyProgram;

// ...

MyClass myObject;

In this case, it is not necessary to use the full name MyProgram::MyClass, as the namespace has been imported with using.

Nested namespaces

Namespaces can be nested within other namespaces, allowing for an organized hierarchy.

namespace Company {
    namespace Project {
        class MainClass {
            // Class code
        };
    }
}

To access MainClass, you can use Company::Project::MainClass or import the nested namespace:

using namespace Company::Project;

MainClass instance;

Namespace aliases

In some cases, it may be useful to define an alias for a namespace, especially if the namespace name is long or if there are name conflicts. This is done with the keyword namespace.

namespace Alias = Long::Namespace::Name;

class ClassWithAlias {
public:
    void Method() {
        Alias::Class instance;
    }
};

Anonymous namespaces

C++ also allows the creation of anonymous namespaces. Elements within an anonymous namespace have file scope, meaning they cannot be accessed from other files.

namespace {
    int internalVariable;
    
    void internalFunction() {
        // Function code
    }
}

Anonymous namespaces are useful for encapsulating implementation details that should not be accessible outside the current file.