> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C++ Nested Namespace A nested namespace in C++ is a namespace declared entirely within the declarative region of another namespace. It establishes a hierarchical scope resolution system. Members defined in deeper lexical scopes can be accessed from outside using explicit qualification via the scope resolution operator (`::`), or through `using` declarations and `using` directives to bypass explicit qualification. ## Traditional Syntax (Pre-C++17) Historically, defining a nested namespace required explicitly nesting the lexical blocks. Each namespace introduces its own scope, and inner scopes have implicit access to enclosing scopes via unqualified name lookup. ```cpp theme={"dark"} namespace Outer { int outer_var = 10; namespace Inner { int inner_var = 20; int calculate() { // Unqualified name lookup resolves outer_var return outer_var + inner_var; } } } ``` ## Nested Namespace Definition (C++17) C++17 introduced a concise syntax for nested namespace definitions. This allows multiple namespace levels to be declared in a single declarative step by concatenating the namespace identifiers with the scope resolution operator. ```cpp theme={"dark"} namespace Outer { int existing_var = 5; } namespace Outer::Inner { int inner_var = 20; int get_sum() { return existing_var + inner_var; } } ``` *Note: This syntax is strictly equivalent to traditional nested blocks. While it does not reopen the `Outer` namespace to add new declarations, code inside `Outer::Inner` retains access to previously declared members of `Outer` via standard unqualified name lookup.* ## Scope Resolution and Access To access members of a nested namespace from outside its enclosing scopes, identifiers must be fully qualified starting from the global scope or the nearest accessible enclosing scope. ```cpp theme={"dark"} #include namespace Outer { namespace Inner { int inner_var = 42; void display() { std::cout << inner_var << '\n'; } } } int main() { // Fully qualified name Outer::Inner::display(); // Accessing variables int val = Outer::Inner::inner_var; return 0; } ``` ## Using Declarations and Directives To mitigate the verbosity of deep qualification, C++ provides `using` declarations and `using` directives. A `using` declaration introduces a specific nested namespace member into the current scope, while a `using` directive makes all names from the nested namespace available for unqualified lookup. ```cpp theme={"dark"} namespace Outer { namespace Inner { int value = 100; void process() {} } } void example_declaration() { using Outer::Inner::value; // using declaration value = 200; // Resolves to Outer::Inner::value } void example_directive() { using namespace Outer::Inner; // using directive process(); // Resolves to Outer::Inner::process } ``` ## Namespace Aliasing Namespace aliasing creates a local synonym for a nested namespace within the current translation unit or block scope, providing another mechanism to shorten long namespace chains. ```cpp theme={"dark"} namespace System { namespace Network { namespace Protocols { namespace TCP { struct Socket { int id; }; } } } } // Create an alias for the deeply nested namespace namespace CoreNet = System::Network::Protocols::TCP; int main() { CoreNet::Socket socket; // Resolves to System::Network::Protocols::TCP::Socket socket.id = 1; return 0; } ``` ## Inline Nested Namespaces (C++20) C++20 extended the C++17 syntax to support the `inline` specifier within a concatenated nested namespace definition. Members of an inline nested namespace are automatically injected into the immediate enclosing namespace's scope. ```cpp theme={"dark"} #include // C++20 syntax namespace Outer::inline Inner { void function() { std::cout << "Inline nested namespace function\n"; } } // Equivalent to: // namespace Outer { // inline namespace Inner { // void function() { ... } // } // } int main() { Outer::function(); // Accessible directly through the enclosing namespace return 0; } ```

Tired of Poor C++ Skills? Fix That With Deep Grasping! Learn More