有限定的名字查找

#include <iostream>
 
namespace M {
    const char* fail = "失败\n";
}
 
using M::fail;
 
namespace N {
    const char* ok = "成功\n";
}
 
using namespace N;

int main()
{
    struct std {};
    
    std::cout << ::fail;   // 错误：对 'std' 的无限定查找找到结构体
    ::std::cout << ::ok; // 正确：::std 找到命名空间 std
}

struct A
{
    static int n;
};

int main()
{
    int A;
    A::n = 42; // 正确：对 :: 左边的 A 的无限定查找忽略变量
    A b;       // 错误：对 A 的无限定查找找到了变量 A
}
 
template<int>
struct B : A {};
 
namespace N
{
    template<int>
    void B();
 
    int f()
    {
        return B<0>::n; // 错误：N::B<0> 不是类型
    }
}

class X {};
 
constexpr int number = 100;
 
struct C
{
    class X {};
    static const int number = 50;
    static X arr[number];
};
 
X C::arr[number], brr[number];    // 错误：对 X 的查找找到 ::X 而不是 C::X
C::X C::arr[number], brr[number]; // OK ：arr 的大小是 50，brr 的大小是 100

struct C { typedef int I; };
 
typedef int I1, I2;
 
extern int *p, *q;
 
struct A { ~A(); };
 
typedef A AB;
 
int main()
{
    p->C::I::~I(); // ~ 之后的名字 I 在 :: 前面的 I 的同一个作用域中查找
                   //（也就是说，在 C 的作用域中查找，因此查找结果是 C::I）
    
    q->I1::~I2();  // 名字 I2 在 I1 的同一个作用域中查找，
                   // 也就是说从当前的作用域中查找，因此查找结果是 ::I2
    
    AB x;
    x.AB::~AB();   // ~ 之后的名字 AB 在 :: 前面的 AB 的同一个作用域中查找
                   // 也就是说从当前的作用域中查找，因此查找结果是 ::AB
}

struct A { A(); };

struct B : A { B(); };

A::A() {} // A::A 指定的是构造函数，用于声明
B::B() {} // B::B 指定的是构造函数，用于声明

B::A ba;  // B::A（在 B 的作用域中查找）指定的是类型 A
A::A a;   // 错误：A::A 不是类型

struct A::A a2; // 正确：详述类型说明符中的查找是忽略函数的，
                // 因此 A::A 在 A 的作用域中查找，于是指定的是类 A
                // （也就是它的注入类名）

struct B { virtual void foo(); };

struct D : B { void foo() override; };

int main()
{
    D x;
    B& b = x;
    
    b.foo();    // 调用 D::foo（虚调用派发）
    b.B::foo(); // 调用 B::foo（静态调用派发）
}

namespace N
{
    template<typename T>
    struct foo {};
 
    struct X {};
}
 
N::foo<X> x; // 错误：X 的查找结果是 ::X 而不是 N::X

int x;
 
namespace Y
{
    void f(float);
    void h(int);
}
 
namespace Z
{
    void h(double);
}
 
namespace A
{
    using namespace Y;
    void f(int);
    void g(int);
    int i;
}
 
namespace B
{
    using namespace Z;
    void f(char);
    int i;
}
 
namespace AB
{
    using namespace A;
    using namespace B;
    void g();
}
 
void h()
{
    AB::g();  // 在 AB 中查找，找到了 AB::g 并且选择了 AB::g(void)
              // （没有在 A 和 B 中查找）
    
    AB::f(1); // 首先在 AB 中查找，没有找到 f
              // 然后在 A 和 B 中查找
              // 找到了 A::f 和 B::f（但没有在 Y 中查找，因此不考虑 Y::f）
              // 重载决议选中 A::f(int)
    
    AB::x++;  // 首先在 AB 中查找，没有找到 x
              // 然后在 A 和 B 中查找。没有找到 x
              // 然后在 Y 和 Z 中查找。还是没有找到 x：这是一个错误
    
    AB::i++;  // 在 AB 中查找，没有找到 i
              // 然后在 A 和 B 中查找。找到了 A::i 和 B::i：这是一个错误
    
    AB::h(16.8); // 首先在 AB 中查找：没有找到 h
                 // 然后在 A 和 B 中查找。没有找到 h
                 // 然后在 Y 和 Z 中查找。
                 // 找到了 Y::h 和 Z::h。重载决议选中 Z::h(double)
}

namespace A { int a; }
 
namespace B { using namespace A; }
 
namespace D { using A::a; }
 
namespace BD
{
    using namespace B;
    using namespace D;
}
 
void g()
{
    BD::a++; // OK ： 通过 B 和 D 找到同一个 A::a
}