What are namespaces and their limitations?

Suppose we’re organizing a concert. There are different areas within the event place. There's a staging area for performances, a food court area for dining, and a lounge area for relaxation.
Let’s assign a name to each area to keep things organized:

The stage area is named as a stage.
The food court area is named as food court.
The lounge area is named as lounge.

In programming, namespaces serve a similar purpose. They’re like named areas where we can group related code together. Each namespace has a unique name, just like each area at the event venue.

Note: The std namespace is a standard namespace that contains many standard C++ functions and objects.

Coding example

Let’s create a customized namespace in the code below:

Code explanation

Line 4–9: We define a namespace called MyNamespace and a function called myFunction() inside that namespace.
Line 13: We call myFunction() using the scope resolution operator :: to specify that we’re calling myFunction() from MyNamespace.

Namespace collision

Namespace collisions can occur when two namespaces have elements (like functions, variables, or classes) with the same name. This can happen if we’re using multiple libraries or if we define our own namespaces with conflicting names.

Let’s create an example to illustrate this collision below:

#include <iostream>
// First namespace
namespace FirstNamespace {
    void display() {
        std::cout << "Hello from FirstNamespace!" << std::endl;
    }
}
// Second namespace with a conflicting name
namespace SecondNamespace {
    void display() {
        std::cout << "Hello from SecondNamespace!" << std::endl;
    }
}
int main() {
    // Attempt to call display() without specifying the namespace
    display(); // This will result in a compilation error due to ambiguity
    // To fix the issue, we need to specify which display() function to call 
    // and comment the above display() call
    FirstNamespace::display();
    SecondNamespace::display();
    return 0;
}