Namespaces in C++ provide a declarative region that localizes identifier visibility, preventing collision between homonymous entities across different logical domains or external libraries.

Collision Avoidance

Consider a scenario where a legacy C header defines a macro or global function that conflicts with application variables:

#include <cstdlib>
int connect = 8080;  // Conflicts with potential networking symbols

int main() {
    // Ambiguity: variable vs. function?
    printf("%d\n", connect);
    return 0;
}

When the preprocessor or linker encounters duplicate identifiers in the global namespace, compilation fails or invokes undefined behavior. C++ namespaces compartmentalize these definitions:

#include <iostream>

namespace socket {
    int connect = 8080;
    const char* protocol = "TCP";
}

int main() {
    std::cout << ::connect << std::endl;      // Global scope (if exists)
    std::cout << socket::connect << std::endl; // Explicit namespace access
    return 0;
}

Declaration Syntax

Define a namespace using the namespace keyword followed by a identifier and brace-enclosed block:

namespace Graphics {
    int width = 1920;
    int height = 1080;
    
    void initialize() {
        std::cout << "Initializing renderer\n";
    }
    
    struct Buffer {
        unsigned char* data;
        size_t capacity;
    };
}

namespace Network {
    int width = 1500;  // MTU size - distinct from Graphics::width
    
    void initialize() {
        std::cout << "Establishing connection\n";
    }
    
    struct Buffer {
        char packet[4096];
        int socket_fd;
    };
}

Access members through the scope resolution operator :::

int main() {
    Graphics::initialize();
    Network::initialize();
    
    Graphics::Buffer frame;
    Network::Buffer stream;
    
    std::cout << "Resolution: " << Graphics::width << "x" << Graphics::height << "\n";
    std::cout << "Frame buffer addr: " << &frame << "\n";
    std::cout << "Stream buffer addr: " << &stream << "\n";
}

Hierarchical Composition

Namespaces support arbitrary nesting to reflect modular architecture:

namespace Engine {
    namespace Physics {
        constexpr float gravity = 9.81f;
        
        class Vector3 {
        public:
            float x, y, z;
        };
    }
    
    namespace Audio {
        constexpr int sample_rate = 44100;
        
        void play_sound(const char* file) {
            // Implementation
        }
    }
}

// C++17 nested namespace shorthand:
namespace Utils::Logging {
    enum Level { DEBUG, INFO, WARN, ERROR };
}

Access nested members through chained qualification:

Engine::Physics::Vector3 velocity;
auto level = Utils::Logging::DEBUG;

Qualified Name Lookup

Explicit qualification guarantees uanmbiguous identifier resolution:

std::cout << "Physics constant: " << Engine::Physics::gravity << " m/s²\n";

For frequently accessed nested namespaces, create namespace aliases to improve readability:

namespace Phys = Engine::Physics;
Phys::Vector3 position;

Using-Declarations vs. Using-Directives

Selective Importation

Introduce specific members into the current scope with out exposing the entire namespace:

using Graphics::width;  // Only 'width' becomes visible
using std::cout;
using std::endl;

int main() {
    cout << "Screen width: " << width << endl;  // Unqualified access
    // height would still require Graphics::height
}

Global Unwrapping

Import all identifiers from a namespace into the current declarative region:

using namespace Network;

int main() {
    initialize();  // Direct access, but risks collision
    Buffer packet; // Ambiguity if Graphics::Buffer also visible
}

Avoid using namespace directives in header files or global scopes of large translation units. Restrict them to function-local scopes or implementation files where the introduced names are immediately evident:

void process_data() {
    using namespace Utils::Logging;  // Limited to this function
    Level current = INFO;
}

Anonymous Namespaces

Unnamed namespaces restrict visibility to the current translation unit, providing internal linkage equivalent to static at namespace scope:

namespace {
    int internal_counter = 0;
    
    void helper_function() {
        ++internal_counter;
    }
}

// Accessible without qualification within this file,
// invisible to other translation units

Inline Namespaces

C++11 inline namespaces automatically expose members to the enclosing namespace without qualification, useful for versioning:

namespace Library {
    inline namespace v2 {
        void process() { /* new implementation */ }
    }
    namespace v1 {
        void process() { /* legacy implementation */ }
    }
}

Library::process();  // Calls v2::process by default
Library::v1::process();  // Explicit version selection