Namespaces

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 外部定义 V 的成员 f
                // 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() {} // 正确
    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() {}     // 正确：全局命名空间包含 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); // 通过 ADL 查找到 A::X::f
    }
    void f(X) {}   // A::f 的定义
    void h(int) {} // A::h 的定义
    // A::f、A::g 和 A::h 现在在命名空间作用域可见
    // 并且它们也是 A::X 和 A::X::Y 的友元
}

namespace
{
    int i; // 定义 ::(unique)::i
}
void f()
{
    i++;   // 递增 ::(unique)::i
}
namespace A
{
    namespace
    {
        int i;        // A::(unique)::i
        int j;        // A::(unique)::j
    }
    void g() { i++; } // A::(unique)::i++
}
using namespace A; // 将A中所有名称引入全局命名空间
void h()
{
    i++;    // 错误：::(unique)::i 与 ::A::(unique)::i 同时存在于作用域中
    A::i++; // 正确：递增 ::A::(unique)::i
    j++;    // 正确：递增 ::A::(unique)::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) 允许在命名空间作用域内重复声明
}
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); // 正确：函数名 g 隐藏了结构体 g
}
void func()
{
    int i;
    using B::i;   // 错误：i 被重复声明
    void f(char);
    using B::f;   // 正确：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;   // 正确：隐藏了 struct 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 X
{
    namespace M
    {
        void g(); // 声明但未定义 X::M::g()
    }
    using M::g;
    void g();     // 错误：尝试声明与 X::M::g() 冲突的 X::g
}

namespace A
{
    int i;
}
namespace B
{
    int i;
    int j;
    namespace C
    {
        namespace D
        {
            using namespace A;
            // A中的名称被"注入"到D中
            // D内的非限定查找会将这些名称视为与全局作用域具有相同层级（例如用于名称隐藏的目的）
            // 引用D的限定查找（对某个名称使用D::name）将找到与D内非限定查找相同的名称
            int j;
            int k;
            int a = i;   // i是B::i，因为A::i被B::i隐藏
            int b = ::i; // 错误：全局命名空间中仍不存在i
        }
        using namespace D; // D和A中的名称被注入到C中
        int k = 89; // 允许声明与using引入的名称相同的标识符
        int l = k;  // 二义性：C::k 还是 D::k
        int m = i;  // 正确：B::i隐藏了A::i
        int n = j;  // 正确：D::j隐藏了B::j
    }
}
// 以下均为等效定义：
int t0 = B::i;
int t1 = B::C::a;
int t2 = B::C::D::a;

namespace D
{
    int d1;
    void f(char);
}
using namespace D; // 将 D::d1、D::f、D::d2、D::f、
                   // E::e 和 E::f 引入全局命名空间！
int d1;            // 正确：声明时不会与 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++;  // 正确
    D::d1++; // 正确
    d2++;    // 正确，d2 是 D::d2
    e++;     // 正确：由于传递性 using，e 是 E::e
    f(1);    // 错误：存在歧义：D::f(int) 还是 E::f(int)？
    f('a');  // 正确：唯一的 f(char) 是 D::f(char)
}