Consider, you are an postman and you got a post-card to deliever to the person named “Raldu”. By case there are two person named as “Raldu” in the town. It would be ambiguous for you to deliever to the right person. In this case you need an additional clue to help you decide, like: Father's name, or House Number.

Similarly, C++ requires that all identifiers to be non-ambiguous. If two identical identifiers are introduced into the same program in a way that the compiler or linker can't tell them apart, then the compiler or linker will produce an error. This error is generally referred to as an naming collision (or naming conflict).

If the colliding identifier introduced into the same file then it would result into the compiler error. If the colliding identifiers are introduced into separate files belonging to the same program, the result would be a linker error.

An Example of Naming Collision:

first.cpp

void func(){
	// do nothing
}

main.cpp

#include <iostream>

void func(){
	// do nothing
}

int main(){
	return 0;
}

When the compiler compiles this program, it will compile first.cpp and main.cpp independently, and each file will compile with no problems.

However, when linker executes, it will link all the definitions in first.cpp and main.cpp together, and discover conflicting definitions for function “func". The linker will then abort with an error. Note that this error occurs even though “func” is never called.

Most naming collisions occur in two cases:

1. Two (or more) identically named functions (or global variables) are introduces into separate files belonging to the same program. This will result in a linker error.
2. Two (or more) identically named functions (or global variables) are introduced into the same file. This will result in a compiler error.

As programs get larger and larger, the chances of naming collision being introduced increases significantly. The good new is that C++ provides plenty of mechanisms for avoiding naming collisions. Local scope, which keeps local variables defined inside functions from conflicting with each other, is one such mechanism. But local scope doesn't work for function names. So how do we keep function names from conflicting with each other?

What is namespace ❓

A namespace is a declarative region that provides a scope for the identifiers (such as variables, functions and classes) inside it. The primary goal of namespaces is to prevent naming collisions in large and collaborative codebases.

Namespaces are often used to group related identifiers in a large project to help ensure they don't inadvertently collide with other identifiers. For example, if you put all your math functions in a namespace called math, then your math functions won't collide with identically named functions outside the math namespace.

Declaring and Defining a Namespace

To declare a namespace in C++, you can use the namespace keyword followed by the desired namespace name. For example:

// Declaration of a namespace named "Example"
namespace Example {
    // Contents of the namespace go here
    int variable;
    void function();
    class MyClass;
}

In this example, we have declared a namespace named “Example” that encapsulates a variable, a function, and a class.

Accessing Entities within a Namespace

Once we have defined a namespace, you can access its entities using the scope resolution operator ::. For instance:

// Accessing the variable inside the "Example" namespace
Example::variable = 42;

// Calling the function inside the "Example" namespace
Example::function();

This syntax ensures that there is no ambiguity in identifying which variable or function you are referring to, even if similar names exist in other namespaces or the global scope.

Nested Namespaces

C++ supports nested namespaces, allowing you to create a hierarchy of namespaces within namespaces. This further enhances the organization and structure of your code. Here' an example:

namespace Outer {
    int variable;

    namespace Inner {
        void function();
    }
}

In this example, we have a namespace “Outer” containing a variable, and within “Outer”, there is a nested namespace “Inner” containing a function.

Anonymous Namespaces

C++ also introduces the concept of anonymous namespaces. Entities declared within an anonymous namespace have internal linkage, meaning they are accessible only within translation unit where they are defined. This can be useful for avoiding naming collisions in large projects.

namespace {
    int internalVariable; // Internal linkage
}

The using Directive

To simplify code and improve readability, you can use the using directive to bring specific entities or an entire namespace into the current scope:

using Example::variable;
using Example::function;

// or

using Example;

// Now you can use "variable" and "function" directly without the namespace prefix
variable = 123;
function();

:: Scope Resolution Operator

Classification

1. Global scope (:: name): used before type names (classes, class members, member functions, variables, etc.) to indicate that the scope is a global namespace.
2. Class scope character (class :: name): used to indicate that the scope of the specified type is specific to a class.
3. Namespace scope (namespace :: name): used to indicate that the scope of the specified type is specific to a namespace.

int count = 11;         // Global (: :) count

class A {
public:
	static int count;   // Count (A::count) of class A
};
int A::count = 21;

void fun()
{
	int count = 31;     // Initialize the local count to 31
	count = 32;         // Set the local count to 32
}

int main() {
	::count = 12;       // Test 1: Set the global count to 12

	A::count = 22;      // Test 2: Set the count of class A to 22

	fun();		        // Test 3

	return 0;
}

Common Use Cases for Namespaces

1. Avoiding Naming Collisions: Namespaces play a crucial role in preventing naming collisions, especially in large projects where multiple developers may contribute code.
2. Organizing Code: By grouping related entities within a namespace, you can improve the organization and maintainability of your codebase.
3. Library Design: Namespaces are often used in library design to encapsulate classes, functions, and constants, providing a clear interface for users.
4. Avoiding Global Namespace Pollution: Using namespaces helps prevent unintentional pollution of the global namespace with numerous identifiers.

Best Practices

1. Choose Descriptive Names: Select meaningful and descriptive names for your namespaces to enhance code readability.
2. Avoid using Directives in Headers: To prevent unintended side effects and naming conflicts, avoid using using directives in header files. Instead, use them selectively in implementation files.
3. Using Unique Names: Ensure that the names of your namespaces are unique within the context of your project to avoid conflicts with third-party libraries.
4. Minimize the Use of using Directives: Use using directives judiciously to avoid polluting the global namespace or causing ambiguity.

Example of Minimizing:

Instead of using namespace std;

Use this:

int x;
std::cin >> x ;
std::cout << x << std::endl;

or 

using std::cin;
using std::cout;
using std::endl;
int x;
cin >> x;
cout << x << endl;