namespace 一知半解
cpp
字数4747 2021-06-23T18:59:13

基本使用

  1. namespace ns_name { declarations } 命名空间定义
  2. inline namespace ns_name { declarations } (since C++11) 类似于 class private 成员,只有在定义的 namespace 中才可见
  3. namespace { declarations } 匿名命名空间类似声明 static 函数,只在本编译单元(文件)内可见
  4. ns_name::name 命名空间内成员的使用
  5. using namspace ns_name; using-directive 将 ns_name 中的名字提升到使用这个语句的 scope
  6. using ns_name::name; using-declaration 将 ns_name 中的 name 提升到这个语句的 scope
  7. namespace name = qualified-namespace; 命名空间的别名,嵌套很深的命名空间可以这样方便使用
  8. namespace ns:name::inline(since C++20)(optional) name {declarations } (since C++17) 嵌套定义 namespace A::B::C {...} 等于 namespace A{ namespace B { namespace C {...} } } namespace A::B::inline C {...} 等于 namespace A::B{inline namespace C {...} } inline 要在除了第一个 namespace 的前面

注意

Using-declarations

Introduce a name that is defined elsewhere into the declarative region where this using-declaration appears

  1. using name 将 name 引入到特定命名空间,有点类似 Rust 模块系统的模块提升

    void f();
    namespace A {
        void g();
    }
     
    namespace X {
        using ::f;        // global f is now visible as ::X::f
        using A::g;       // A::g is now visible as ::X::g
        using A::g, A::g; // (C++17) OK: double declaration allowed at namespace scope
    }
     
    void h()
    {
        X::f(); // calls ::f
        X::g(); // calls A::g
    }
    
  2. using 之后 reopen 命名空间的内容不生效

    namespace A {
        void f(int);
    }
    using A::f; // ::f is now a synonym for A::f(int)
     
    namespace A {     // namespace extension
        void f(char); // does not change what ::f means
    }
     
    void foo() {
        f('a'); // calls f(int), even though f(char) exists.
    }
     
    void bar() {
        using A::f; // this f is a synonym for both A::f(int) and A::f(char)
        f('a');     // calls f(char)
    }
    
  3. 不能引入命名空间,只能引入命名空间内的一个名字,并且在同一个 scope 内的所有限制都一样

    namespace A {
        int x;
    }
     
    namespace B {
        int i;
        struct g { };
        struct x { };
        void f(int);
        void f(double);
        void g(char); // OK: function name g hides struct g
    }
     
    void func() {
        int i;
        using B::i;   // error: i declared twice
     
        void f(char);
        using B::f;   // OK: f(char), f(int), f(double) are overloads
        f(3.5);       // calls B::f(double)
     
        using B::g;
        g('a');       // calls B::g(char)
        struct g g1;  // declares g1 to have type struct B::g
     
        using B::x;
        using A::x;   // OK: hides struct B::x
        x = 99;       // assigns to A::x
        struct x x1;  // declares x1 to have type struct B::x
    }
    
    //-------- 分隔
    namespace B {
        void f(int);
        void f(double);
    }
     
    namespace C {
        void f(int);
        void f(double);
        void f(char);
    }
     
    void h() {
        using B::f;  // introduces B::f(int), B::f(double)
        using C::f;  // introduces C::f(int), C::f(double), and C::f(char)
        f('h');      // calls C::f(char)
        f(1);        // error: B::f(int) or C::f(int)?
        void f(int); // error: f(int) conflicts with C::f(int) and B::f(int)
    }
    

Using-directives

Using-directives are allowed only in namespace scope and in block scope

Using-directive does not add any names to the declarative region in which it appears (unlike the using-declaration), and thus does not prevent identical names from being declared.

namespace D {
    int d1;
    void f(char);
}
using namespace D; // introduces D::d1, D::f, D::d2, D::f,
                   //  E::e, and E::f into global namespace!
 
int d1;            // OK: no conflict with D::d1 when declaring
namespace E {
    int e;
    void f(int);
}
 
namespace D {          // namespace extension
    int d2;
    using namespace E; // transitive using-directive
    void f(int);
}
 
void f() {
    d1++;    // error: ambiguous ::d1 or D::d1?
    ::d1++;  // OK
    D::d1++; // OK
    d2++;    // OK, d2 is D::d2
    e++;     // OK: e is E::e due to transitive using
    f(1);    // error: ambiguous: D::f(int) or E::f(int)?
    f('a');  // OK: the only f(char) is D::f(char)
}

一些例子

namespace Q {
    namespace V {   // V is a member of Q, and is fully defined within Q
// namespace Q::V { // C++17 alternative to the above two lines
        class C { void m(); }; // C is a member of V and is fully defined within V
                               // C::m is only declared
        void f(); // f is a member of V, but is only declared here
    }
 
    void V::f() // definition of V's member f outside of V
                // f's enclosing namespaces are still the global namespace, Q, and Q::V
    {
        extern void h(); // This declares ::Q::V::h
    }
 
    void V::C::m() // definition of V::C::m outside of the namespace (and the class body)
                   // enclosing namespaces are the global namespace, Q, and Q::V
    {}
}