Qualified name lookup

#include <iostream>
namespace M {
    const char* fail = "fail\n";
}
using M::fail;
namespace N {
    const char* ok = "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]; // 正确：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 命名类型 A（在 B 的作用域中查找）
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++; // 正确：通过 B 和 D 都能找到同一个 A::a
}