Unqualified name lookup

int n = 1;     // n的声明
int x = n + 1; // 正确：查找找到 ::n
int z = y - 1; // 错误：查找失败
int y = 2;     // y的声明

int n = 1; // 声明
namespace N
{
    int m = 2;
    namespace Y
    {
        int x = n; // 正确：查找找到 ::n
        int y = m; // 正确：查找找到 ::N::m
        int z = k; // 错误：查找失败
    }
    int k = 3;
}

namespace X
{
    extern int x; // 声明而非定义
    int n = 1;    // 首先找到
}
int n = 2;        // 其次找到
int X::x = n;     // 找到 X::n，将 X::x 设为 1

namespace A
{
    namespace N
    {
        void f();
        int i = 3; // 第3个被找到（如果第2个不存在）
    }
    int i = 4;     // 第4个被找到（如果第3个不存在）
}
int i = 5;         // 第5个被找到（如果第4个不存在）
void A::N::f()
{
    int i = 2;     // 第2个被找到（如果第1个不存在）
    while (true)
    {
       int i = 1;  // 第1个被找到：查找完成
       std::cout << i;
    }
}
// int i;          // 未找到
namespace A
{
    namespace N
    {
        // int i;  // 未找到
    }
}

namespace M
{
    // const int i = 1; // 永远不会被找到
    class B
    {
        // static const int i = 3;     // 第3个被找到（但无法通过访问检查）
    };
}
// const int i = 5;                    // 第5个被找到
namespace N
{
    // const int i = 4;                // 第4个被找到
    class Y : public M::B
    {
        // static const int i = 2;     // 第2个被找到
        class X
        {
            // static const int i = 1; // 第1个被找到
            int a[i]; // i 的使用
            // static const int i = 1; // 永远不会被找到
        };
        // static const int i = 2;     // 永远不会被找到
    };
    // const int i = 4;                // 永远不会被找到
}
// const int i = 5;                    // 永远不会被找到

class B
{
    // int i;         // 第3处找到
};
namespace M
{
    // int i;         // 第5处找到
    namespace N
    {
        // int i;     // 第4处找到
        class X : public B
        {
            // int i; // 第2处找到
            void f();
            // int i; // 同样第2处找到
        };
        // int i;     // 第4处找到
    }
}
// int i;             // 第6处找到
void M::N::X::f()
{
    // int i;         // 第1处找到
    i = 16;
    // int i;         // 始终找不到
}
namespace M
{
    namespace N
    {
        // int i;     // 始终找不到
    }
}

struct X { void f(); };
struct B1: virtual X { void f(); };
struct B2: virtual X {};
struct D : B1, B2
{
    void foo()
    {
        X::f(); // 正确：调用 X::f（限定查找）
        f(); // 正确：调用 B1::f（非限定查找）
    }
};
// C++98 规则：B1::f 会隐藏 X::f，因此即使通过 B2 可以从 D 访问到 X::f，
// 通过 D 进行的名称查找也无法找到它。
// C++11 规则：在 D 中对 f 的查找集为空，继续在基类中查找
//  在 B1 中对 f 的查找集找到 B1::f，查找完成
// 合并操作替换空集，现在 C 中对 f 的查找集包含在 B1 中找到的 B1::f
//  在 B2 中对 f 的查找集为空，继续在基类中查找
//    在 X 中对 f 的查找找到 X::f
//  合并操作替换空集，现在 B2 中对 f 的查找集包含在 X 中找到的 X::f
// 合并到 C 时发现，B2 查找集中的每个子对象（X）都是已合并子对象（B1）的基类
// 因此 B2 的查找集被丢弃
// C 最终仅保留在 B1 中找到的 B1::f
// （如果使用 struct D : B2, B1，最后一次合并将*替换* C 当前已合并的 X::f，
//  因为已添加到 C 的每个子对象（即 X）都是新集合（B1）中至少一个子对象的基类，
//  最终结果相同：C 中的查找集仅包含在 B1 中找到的 B1::f）

struct V { int v; };
struct B
{
    int a;
    static int s;
    enum { e };
};
struct B1 : B, virtual V {};
struct B2 : B, virtual V {};
struct D : B1, B2 {};
void f(D& pd)
{
    ++pd.v;       // 正确：只有一个v，因为只有一个虚基类子对象
    ++pd.s;       // 正确：只有一个静态成员B::s，即使在B1和B2中都能找到
    int i = pd.e; // 正确：只有一个枚举值B::e，即使在B1和B2中都能找到
    ++pd.a;       // 错误，存在歧义：B1中的B::a和B2中的B::a
}

int i = 3;                     // 对f1找到第3个，对f2找到第2个
struct X
{
    static const int i = 2;    // 对f1找到第2个，对f2始终找不到
    friend void f1(int x)
    {
        // int i;              // 找到第1个
        i = x;                 // 找到并修改 X::i
    }
    friend int f2();
    // static const int i = 2; // 在类作用域内任意位置对f1找到第2个
};
void f2(int x)
{
    // int i;                  // 找到第1个
    i = x;                     // 找到并修改 ::i
}

template<class T>
struct S;
// 其成员函数被声明为友元的类
struct A
{ 
    typedef int AT;
    void f1(AT);
    void f2(float);
    template<class T>
    void f3();
    void f4(S<AT>);
};
// 为 f1、f2 和 f3 授予友元权限的类
struct B
{
    typedef char AT;
    typedef float BT;
    friend void A::f1(AT);    // 对 AT 的查找找到 A::AT（在 A 中找到 AT）
    friend void A::f2(BT);    // 对 BT 的查找找到 B::BT（在 A 中未找到 BT）
    friend void A::f3<AT>();  // 对 AT 的查找找到 B::AT（不在 A 中查找，
                              //     因为 AT 位于声明符标识符 A::f3<AT> 中）
};
// 为 f4 授予友元权限的类模板
template<class AT>
struct C
{
    friend void A::f4(S<AT>); // 对 AT 的查找找到 A::AT
                              //（AT 不在声明符标识符 A::f4 中）
};

class X
{
    int a, b, i, j;
public:
    const int& r;
    X(int i): r(a),      // 将 X::r 初始化为引用 X::a
              b(i),      // 将 X::b 初始化为参数 i 的值
              i(i),      // 将 X::i 初始化为参数 i 的值
              j(this->i) // 将 X::j 初始化为 X::i 的值
    {}
};
int a;
int f(int a, int b = a); // 错误：查找 a 时找到的是参数 a 而非 ::a
                         // 且不允许将参数用作默认实参

struct X
{
    static int x;
    static const int n = 1; // 首先找到
};
int n = 2;                  // 其次找到
int X::x = n;               // 找到 X::n，将 X::x 设为 1 而非 2

const int RED = 7;
enum class color
{
    RED,
    GREEN = RED + 2, // RED 查找 color::RED，而非 ::RED，因此 GREEN = 2
    BLUE = ::RED + 4 // 限定查找找到 ::RED，BLUE = 11
};

int n = 3;          // 找到第3个
int f(int n = 2)    // 找到第2个
try
{
    int n = -1;     // 从未找到
}
catch(...)
{
    // int n = 1;   // 找到第1个
    assert(n == 2); // 查找n时找到函数参数f
    throw;
}

struct A {};
void operator+(A, A);  // 用户定义的非成员 operator+
struct B
{
    void operator+(B); // 用户定义的成员 operator+
    void f();
};
A a;
void B::f() // B 成员函数的定义
{
    operator+(a, a); // 错误：从成员函数进行的常规名称查找
                     // 会在 B 的作用域中找到 operator+ 的声明
                     // 并在此停止，永远不会到达全局作用域
    a + a; // 正确：成员查找找到 B::operator+，非成员查找
           // 找到 ::operator+(A, A)，重载决议选择 ::operator+(A, A)
}

void f(char); // f 的首次声明
template<class T> 
void g(T t)
{
    f(1);    // 非依赖名称：查找找到 ::f(char) 并立即绑定
    f(T(1)); // 依赖名称：查找推迟
    f(t);    // 依赖名称：查找推迟
//  dd++;    // 非依赖名称：查找未找到声明
}
enum E { e };
void f(E);   // f 的第二次声明
void f(int); // f 的第三次声明
double dd;
void h()
{
    g(e);  // 实例化 g<E>，此时
           // 对名称 'f' 的第二次和第三次使用进行查找
           // 找到 ::f(char)（通过常规查找）和 ::f(E)（通过 ADL）
           // 重载决议选择 ::f(E)
           // 这里调用 f(char) 一次，然后调用 f(E) 两次
    g(32); // 实例化 g<int>，此时
           // 对名称 'f' 的第二次和第三次使用进行查找
           // 仅找到 ::f(char)
           // 重载决议选择 ::f(char)
           // 这里调用 f(char) 三次
}
typedef double A;
template<class T>
class B
{
    typedef int A;
};
template<class T>
struct X : B<T>
{
    A a; // 对 A 的查找找到 ::A (double)，而非 B<T>::A
};