What and how to use namespaces in C++

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

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 the classes and other elements.

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

Using namespaces

To use a namespace in a C++ program, there are two ways to do it:

Using the full type name

When using the full type name, 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 like this:

MyProgram::MyClass myObject;

Importing the namespace

Another way to use a namespace is by 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.