命名空间

namespace Q {
  namespace V { // V 是 Q 的成员，且完全在 Q 内定义
// namespace Q::V { // C++17 中对上述二行的替代写法
    class C { void m(); }; // C 是 V 的成员且完全定义于 V 内
                           // C::m 仅声明
    void f(); // f 是 V 的成员，但只在此声明
  }
  void V::f() // V 的成员 f 的 V 外定义
              // f 的外围命名空间仍是全局命名空间、Q 与 Q::V
  {
      extern void h(); // 这声明 ::Q::V::h
  }
  void V::C::m() // V::C::m 的命名空间（及类）外定义
                 // 外围命名空间是全局命名空间、Q 与 Q::V
  {
  }
}

namespace Q {
  namespace V { // V 的原初命名空间定义
    void f(); // Q::V::f 的声明
  }
  void V::f() {} // OK
  void V::g() {} // 错误：g() 仍不是 V 的成员
  namespace V { // V 的扩展命名空间定义
    void g(); // Q::V::g 的声明
  }
}
namespace R { // 不是 Q 的外围命名空间
   void Q::V::g() {} // 错误：不能在 R 内定义 Q::V::g
}
void Q::V::g() {} // OK：全局命名空间包围 Q

void h(int);
namespace A {
  class X {
    friend void f(X); // A::f 是友元
    class Y {
        friend void g(); // A::g 是友元
        friend void h(int); // A::h 是友元，与 ::h 不冲突
    };
  };
  // A::f、A::g 与 A::h 在命名空间作用域不可见
  // 虽然它们是命名空间 A 的成员
  X x;
  void g() {  // A::g 的定义
     f(x); // A::X::f 通过 ADL 找到
  }
  void f(X) {}       // A::f 的定义
  void h(int) {}     // A::h 的定义
  // A::f 、 A::g 与 A::h 现在在命名空间作用域可见
  // 而且它们亦是 A::X 与 A::X::Y 的友元
}

namespace {
    int i;  // 定义 ::(独有)::i
}
void f() {
    i++;  // 自增 ::(独有)::i
}
 
namespace A {
    namespace {
        int i; // A::(独有)::i
        int j; // A::(独有)::j
    }
    void g() { i++; } // A::(独有)::i++
}
 
using namespace A; // 从 A 引入所有名称到全局命名空间
void h() {
    i++;    // 错误：::(独有)::i 与 ::A::(独有)::i 均在作用域中
    A::i++; // OK：自增 A::(独有)::i
    j++;    // OK：自增 A::(独有)::j
}

void f();
namespace A {
    void g();
}
namespace X {
    using ::f; // 全局 f 现在作为 ::X::f 可见
    using A::g; // A::g 现在作为 ::X::g 可见
    using A::g, A::g; // (C++17) OK：命名空间作用域允许双重声明
}
void h()
{
    X::f(); // 调用 ::f
    X::g(); // 调用 A::g
}

namespace A {
    void f(int);
}
using A::f; // ::f 现在是 A::f(int) 的同义词
 
namespace A { // 命名空间扩展
   void f(char); // 不更改 ::f 的含义
}
void foo() {
    f('a'); // 调用 f(int)，即使 f(char) 存在。
} 
void bar() {
   using A::f; // 此 f 是 A::f(int) 与 A::f(char) 的同义词
   f('a'); // 调用 f(char)
}

namespace A {
    int x;
}
namespace B {
    int i;
    struct g { };
    struct x { };
    void f(int);
    void f(double);
    void g(char); // OK：函数名 g 隐藏类 g
}
void func() {
    int i;
    using B::i; // 错误：两次声明 i
 
    void f(char);
    using B::f; // OK：f(char)、f(int)、f(double) 是重载
    f(3.5); // 调用 B::f(double)
 
    using B::g;
    g('a');      // 调用 B::g(char)
    struct g g1; // 声明 g1 拥有类型 struct B::g
 
    using B::x;
    using A::x;  // OK ：隐藏 B::x
    x = 99;      // 赋值给 A::x
    struct x x1; // 声明 x1 拥有类型 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; // 引入 B::f(int) 、 B::f(double)
    using C::f; // 引入 C::f(int) 、 C::f(double) 及 C::f(char)
    f('h');      // 调用 C::f(char)
    f(1);        // 错误：B::f(int) 或 C::f(int) ？
    void f(int); // 错误：f(int) 与 C::f(int) 及 B::f(int) 冲突
}

namespace A {
    int i;
}
namespace B {
    int i;
    int j;
    namespace C {
        namespace D {
            using namespace A; // 注入所有来自 A 的名称到全局命名空间
            int j;
            int k;
            int a = i; // i 是 B::i，因为 B::i 隐藏 A::i
        }
        using namespace D; // 注入来自 D 的名称到 C
                           // 注入来自 A 的名称到全局命名空间
        int k = 89; // 声明与用 using 引入者等同的名称 OK
        int l = k;  // 歧义：C::k 或 D::k
        int m = i;  // OK：B::i 隐藏 A::i
        int n = j;  // OK：D::j 隐藏 B::j
    }
}

namespace D {
   int d1;
   void f(char);
}
using namespace D; // 引入 D::d1、D::f、D::d2、D::f，
                   // E::e 及 E::f 到全局命名空间！
 
int d1; // OK：声明时与 D::d1 不冲突
namespace E {
    int e;
    void f(int);
}
namespace D { // 命名空间扩展
    int d2;
    using namespace E; // 传递性 using 指令
    void f(int);
}
void f() {
    d1++; // 错误：歧义：::d1 或 D::d1？
    ::d1++; // OK
    D::d1++; // OK
    d2++; // OK，d2 是 D::d2
    e++; // OK：e 是 E::e，因为传递性 using
    f(1); // 错误：歧义：D::f(int) 或 E::f(int)？
    f('a'); // OK：仅有的 f(char) 是 D::f(char)
}