无限定的名字查找

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

int n = 1; // 声明
namespace N {
  int m = 2;
  namespace Y {
    int x = n; // OK，查找 ::n
    int y = m; // OK，查找 ::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; // 找到第三个（如果第二个没找到）
    }
    int i=4; // 找到第四个（如果第三个没找到）
}
 
int i=5; // 找到第五个（如果第四个没找到）
 
void A::N::f() {
    int i = 2; // 找到第二个（如果第一个没找到）
    while(true) {
       int i = 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; // 找到了第三个（但之后会被访问检查所拒绝）
    };
}
// const int i = 5; // 找到了第五个
namespace N {
    // const int i = 4; // 找到了第四个
    class Y : public M::B {
        // static const int i = 2; // 找到了第二个
        class X {
            // static const int i = 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; // 找到第三个
};
namespace M {
    // int i; // 找到第五个
    namespace N {
        // int i; // 找到第四个
        class X : public B {
            // int i; // 找到第二个
            void f();
            // int i; // 也找到第二个
        };
        // int i; // 找到第四个
    }
}
// int i; // 找到第六个
void M::N::X::f()
{
    // int i; // 找到第一个
    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(); // OK，调用了 X::f（有限定查找）
        f(); // OK，调用了 B1::f（无限定查找）
// C++98 规则：B1::f 隐藏 X::f，因此即便从 D 通过 B2 可以访问到 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 中的 X::f，因为已经加入到 C 中的每个子对象（就是 X）
//  都是新集合（B1）中的至少一个子对象的基类，
//  其最终结果是一样的：C 的查找集合只包含在 B1 中找到的 B1::f）
    }
};

struct V { int v; };
struct A {
        int a;
        static int s;
        enum { e };
};
struct B : A, virtual V { };
struct C : A, virtual V { };
struct D : B, C { };
 
void f(D& pd) {
        ++pd.v; // OK：只有一个 v，因为只有一个虚基类子对象
        ++pd.s; // OK：只有一个静态的 A::s，即便在 B 和 C 中都找到了它
        int i = pd.e; // OK：只有一个枚举符 A::e，即便在 B 和 C 中都找到了它
        ++pd.a; // 错误，有歧义：B 中的 A::a 和 C 中的 A::a
}

int i = 3; // f1 找到的第三个，f2 找到的第二个
struct X {
    static const int i = 2; // f1 找到的第二个，f2 找不到这个
    friend void f1(int x)
    {
        // int i; // 找到第一个
        i = x; // 找到并改动 X::i
    }
    friend int f2();
    // static const int i = 2; // f1 在类作用域中的任何地方找到第二个
};
void f2(int x) {
    // int i; // 找到第一个
    i = x; // 找到并改动 ::i
}

// 这个类的成员函数被作为友元
struct A { 
    typedef int AT;
    void f1(AT);
    void f2(float);
    template <class T> void f3();
};
 
// 这个类授予友元关系
struct B {
    typedef char AT;
    typedef float BT;
    friend void A::f1(AT); // 对 AT 的查找找到的是 A::AT
    friend void A::f2(BT); // 对 BT 的查找找到的是 B::BT 
    friend void A::f3<AT>(); // 对 AT 的查找找到的是 B::AT 
};

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; // 找到第三个
int f(int n = 2) // 找到第二个
try {
   int n = -1;  // 找不到这个
} catch(...) {
   // int n = 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; // OK：成员查找找到了 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
};