1
std::cout << 1;  // 解析"cout"时，去命名空间std中进行查找
2
struct A {
3
    typedef int type;
4
};
5
A::type a;  // 解析"type"时，去A类作用域中查找

1
#include <iostream>
2
int main() {
3
    struct std {};
4
    std::cout << "fail\n";  // Error: unqualified lookup for 'std' finds the struct
5
    ::std::cout << "ok\n";  // OK: ::std finds the namespace std
6
}

1
struct A {
2
    static int n;
3
};
4
int A::n = 0;
5
int main() {
6
    int A;
7
    A::n = 42;   // OK: 对"A"进行"unqualified lookup"时，忽略了本地变量A
8
    A b;         // 错误: 对"A"进行"unqualified lookup"会指向本地变量A
9
    struct A b;  // A 前面需要增加tag "struct" 进行限定，以避免被本地变量A遮盖
10
}

1
class X {};
2
constexpr int number = 100;
3
struct C {
4
    class X {};
5
    static const int number = 50;
6
    static X arr[number];
7
};
8
X C::arr[number],
9
    brr[number];  // 错误: "X"经过`unqualified name`解析为`::X`与`C::arr`对应的`C::X`不同。
10
C::X C::arr[number], brr[number];  // OK: `C::arr`的长度为50，`brr`的长度为100
11
// `C::arr[number]`中的`number`受同一个声明中的"qualified name"`C::arr`
12
// 的影响，回去类作用域`C`中查找，得到`C::number`，也就是50。而`brr[number]`
13
// 与`C::arr[number]`不是同一个声明，则不受这种影响，得到`::number`，也就是100

1
struct C {
2
    typedef int I;
3
};
4
typedef int I1, I2;
5
extern int *p, *q;
6
struct A {
7
    ~A();
8
};
9
typedef A AB;
10
int main() {
11
    p->C::I::~I();  // 解析`~I()`时，使用`C::I`这个`name`相同的域`C::`，则找到了`C::I`
12
    q->I1::~I2();  // 解析`~I2()`时，使用`::I1`这个`name`相同的域，则找到了`::I2`
13
    AB x;
14
    x.AB::~AB();  // ~ 之后的名字 AB 在 :: 前面的 AB 的同一个作用域中查找
15
                  // 也就是说从当前的作用域中查找，因此查找结果是 ::AB
16
}

1
struct B {
2
    virtual void foo();
3
};
4
struct D : B {
5
    void foo() override;
6
};
7
int main() {
8
    D x;
9
    B &b = x;
10
    b.foo();     // calls D::foo (virtual dispatch)
11
    b.B::foo();  // calls B::foo (static dispatch)
12
}

1
namespace N {
2
    template <typename T>
3
    struct foo {};
4
    struct X {};
5
}  // namespace N
6
N::foo<X> x;  // 错误："X"被解析为"::X"，而不是"N::X"

1
int x;
2
namespace Y {
3
    void f(float);
4
    void h(int);
5
}  // namespace Y
6
namespace Z {
7
    void h(double);
8
}  // namespace Z
9
namespace A {
10
    using namespace Y;
11
    void f(int);
12
    void g(int);
13
    int i;
14
}  // namespace A
15
namespace B {
16
    using namespace Z;
17
    void f(char);
18
    int i;
19
}  // namespace B
20
namespace AB {
21
    using namespace A;
22
    using namespace B;
23
    void g();
24
}  // namespace AB
25
void h() {
26
    AB::g();  // 首先考虑"AB::g"，则不再对namespace A、B进行查找
27
    AB::f(1);  // 首先在namespace AB中查找，未匹配，然后到namespace A、B中查找，查找到"A::f"和"B::f"，
28
               // 有匹配，则不再对namespace Y进行查找。然后在"A::f"和"B::f"中间选择了"A::f(int)"。
29
    AB::x++;  // 首先在namespace AB中查找，未匹配。然后到namespace A、B中查找，未匹配。
30
              // 然后到namespace Y、Z中查找，未匹配。然后报错。
31
    AB::i++;  // 首先在namespace AB中查找，未匹配。然后到namespace A、B中查找，匹配到"A::i"和"B::i"
32
              // 存在冲突，报错。
33
    AB::h(16.8);  // 首先在namespace AB中查找，未匹配。然后到namespace A、B中查找，未匹配。
34
                  // 然后到namespace Y、Z中查找，匹配到"Y::h"和"Z::h"，选择"Z::h(double)"
35
}

1
namespace A {
2
    int a;
3
}  // namespace A
4
namespace B {
5
    using namespace A;
6
}  // namespace B
7
namespace D {
8
    using A::a;
9
}  // namespace D
10
namespace BD {
11
    using namespace B;
12
    using namespace D;
13
}  // namespace BD
14
void g() {
15
    BD::a++;  // 首先在 namespace BD 中查找，未匹配。然后到 namespace B、D中查找，未匹配。
16
              // 再下面，namespace B、D都同时指向了 namespace A，则在 namespace A 中匹
17
              // 配到 A::a，选择 "A::a"
18
}

1
namespace X {
2
    extern int x;  // 声明，不是定义
3
    int n = 1;  // 在解析x的定义时，其引用了unqualified name “n”，先从其定义域"X"开始搜索，首先发现 n=1
4
};  // namespace X
5

6
int n = 2;     // 如果X::n不存在时，则匹配::n，否则被遮盖。
7
int X::x = n;  // X::x的定义式，X::x的定义在其命名空间"X"外，且引用了unqualified name “n”，
8
               // 在解析"n"时，匹配X::n，则X::x为1

1
namespace A {
2
    namespace N {
3
        void f();
4
        int i = 3;  // 3: 查找"命名空间"，如果将①②注释掉，这句定义存在，则"i"的定义匹配此处，则i=3
5
    }  // namespace N
6
    int i = 4;  // 4: 查找"外层命名空间"，如果将①②③注释掉，这句定义存在，则"i"的定义匹配此处，则i=4
7
}  // namespace A
8

9
int i = 5;  // 5: 查找"全局域"，如果将①②③④注释掉，这句定义存在，则"i"的定义匹配此处，则i=5
10

11
// 在命名空间外定义了一个非成员函数f()，这个例子的注释需要按照序号来看。
12
void A::N::f() {
13
    int i = 2;  // 2: 其次查找"外层代码块"，如果将①注释掉，这句定义存在，则"i"的定义匹配此处，则i=2
14
    {
15
        int i = 1;  // 1: 首先查找“本地代码块”，如果这句定义存在，则"i"的定义匹配此处，则i=1
16
        std::cout << i;  // 0: 在代码块中引用了unqualified name "i"，则需要查找"i"的定义
17
    }
18
}
19

20
// int i; // 如果将5移动到f()定义之后则不参与"i"的查找
21

22
namespace A {
23
    namespace N {
24
        // int i; // 如果将3移动到f()定义之后则不参与"i"的查找
25
    }
26
}  // namespace A

1
namespace M {
2
    // const int i = 1; // 找不到这个
3
    class B {
4
        // const const int i = 3; // 找到了第三个（但之后会被访问检查所拒绝）
5
    };
6
}  // namespace M
7
// const int i = 5; // 找到了第五个
8
namespace N {
9
    // const int i = 4; // 找到了第四个
10
    class Y : public M::B {
11
        // static const int i = 2; // 找到了第二个
12
        class X {
13
            // static const int i = 1; // 找到了第一个
14
            int a[i];  // use of i
15
            // static const int i = 1; // 找不到这个
16
        };
17
        // static const int i = 2; // 找不到这个
18
    };
19
    // const int i = 4; // 找不到这个
20
}  // namespace N
21
// const int i = 5; // 找不到这个

1
class B {
2
    int i;  // 4: 如果1 2 3不存在，”i“匹配此处
3
};
4
namespace M {
5
    int i;  // 6: 如果1 2 3 4 5不存在，”i“匹配此处
6
    namespace N {
7
        int i;  // 5: 如果1 2 3 4不存在，”i“匹配此处
8
        class X : public B {
9
            int i;     // 3: 如果1 2不存在，”i“匹配此处
10
            void f();  // 0: class X中声明了一个函数f()
11
            // int i; // 将3移动到这里也OK，类成员的可见性受声明的位置的影响。
12
        };
13
        // int i; // 5移动到这里也可以，跟f()实现代码的位置有关，与f()声明的位置无关
14
    }  // namespace N
15
}  // namespace M
16

17
int i;  // 7: 如果1 2 3 4 5 6 7不存在，”i“匹配此处
18

19
// 定义class X中声明的函数f()
20
void M::N::X::f() {
21
    int i;  // 2: 如果2不存在，”i“匹配此处
22
    {
23
        int i;  // 2: 如果2存在，”i“首先匹配此处
24
        i = 16;
25
    }
26

27
    // int i; // 如果这句存在，1 2都不存在，也不会匹配此处，因为其出现在调用i的代码块之后
28
}
29
namespace M {
30
    namespace N {
31
      // int i; // 5移动到这里不匹配，其出现在f()实现代码之后
32
    }
33
}  // namespace M

1
struct X {
2
    void f();
3
};
4
struct B1 : virtual X {
5
    void f();
6
};
7
struct B2 : virtual X {};
8
struct D : B1, B2 {
9
    void foo() {
10
        X::f();  // OK，调用了 X::f（有限定查找）
11
        f();     // OK，调用了 B1::f（无限定查找）
12
/*
13
C++98 规则：B1::f 隐藏 X::f，因此即便从 D 通过 B2 可以访问到 X::f，它也不能从 D 中的名字查找所找到。
14
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）
15
*/
16
    }
17
};
18
#include <iostream>
19

20
struct X {
21
    void f() { std::cout << "X::f()" << std::endl; }
22
};
23
struct B1 : virtual X {
24
    void f() { std::cout << "B1::f()" << std::endl; }
25
};
26
struct B2 : X {};
27
struct D : B1, B2 {
28
    void foo() {
29
        X::f();  // OK，调用了 X::f（有限定查找）
30
        f();  // 由于D还通过B2的渠道非虚继承了X，则X::f()不会被B1::f()遮盖掉，所以此处发生歧义错误。
31
    };
32
};
33

34
struct V {
35
    int v;
36
};
37
struct A {
38
    int a;
39
    static int s;
40
    enum { e };
41
};
42
struct B : A, virtual V {};
43
struct C : A, virtual V {};
44
struct D : B, C {};
45

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

1
struct X {
2
    static int x;
3
    static const int n = 1;
4
};
5
int n = 2;
6
int X::x = n;  // 找到了 X::n，将 X::x 设置为 1 而不是 2

1
int i = 3;  // 3: 当1 2不存在时，f1中的"i"匹配此处
2
            // 3: 当1 2不存在时，f2中的"i"也不会匹配此处
3
struct X {
4
    static const int i = 2; // 2: 当这句定义存在时，1不存在时，f1中的"i"匹配此处
5
                            // 2: 当1不存在时，f2中的"i"也不会匹配此处
6
    friend void f1(int x)
7
    {
8
        int i; // 1: 当这句定义存在时，f1中的"i"匹配此处
9
        i = x; // 0: 友元函数f1(int)被定义在类X作用域内部时，"i"的查找顺序与X的成员函数查找顺序相同
10
    }
11
    friend int f2();
12
    // static const int i = 2; // ②移动到此处也OK
13
};
14
void f2(int x) {
15
    int i; // 1: 当这句定义存在时，f2中的"i"匹配此处
16
    i = x; // 0: 友元函数f2(int)被定义在类X作用域外部时，"i"的查找顺序f2(int)所在命名空间的普通函数的查找顺序相同
17
}

1
// 这个类的成员函数被作为友元
2
struct A {
3
    typedef int AT;
4
    void f1(AT);
5
    void f2(float);
6
    template <class T>
7
    void f3();
8
};
9

10
// 这个类授予友元关系
11
struct B {
12
    typedef char AT;
13
    typedef float BT;
14
    friend void A::f1(AT);  // 对 "AT" 的查找时，先到类作用域A中进行查找，匹配"A::AT"
15
    friend void A::f2(BT);  // 对 "BT" 的查找时，先到类作用域A中进行查找，未匹配，
16
                            // 再去类作用域B中查找，匹配"B::BT"
17
    friend void
18
    A::f3<AT>();  // 对 "AT" 的查找时，"AT"是模板参数，则直接去类作用域B中查找，匹配"B::AT"
19
};

1
class X {
2
    int a, b, i, j;
3

4
   public:
5
    const int &r;
6
    X(int i)
7
        : r(a),       // 将 X::r 初始化为指代 X::a
8
          b(i),       // 将 X::b 初始化为形参 i 的值
9
          i(i),       // 将 X::i 初始化为形参 i 的值
10
          j(this->i)  // 将 X::j 初始化为 X::i 的值
11
    {}
12
}
13

14
int a;
15
int f(int a, int b = a);  // 错误：对 a 的查找找到了形参 a，而不是 ::a
16
                          // 但在默认实参中不允许使用形参

1
const int RED = 7;
2
enum class color {
3
    RED,
4
    GREEN = RED + 2,  // RED 找到了 color::RED ，而不是 ::RED ，因此 GREEN = 2
5
    BLUE = ::RED + 4  // 通过 qualified name lookup 找到 ::RED ， BLUE = 11
6
};

1
int n = 3;          // 3
2
int f(int n = 2) {  // 2
3
    try {
4
        int n = -1;  // 不会匹配到该处
5
    } catch (...) {
6
        // int n = 1;   // 1: 加入此处存在，则匹配该处
7
        assert(n == 2);  // 0: n 按1 2 3的顺序进行依次查找，匹配f的参数n，即2
8
        throw;
9
    }
10
    return 0;
11
}

1
struct A {};
2
void operator+(A, A);  // 用户定义的非成员 operator+
3

4
struct B {
5
    void operator+(B);  // 用户定义的成员 operator+
6
    void f();
7
};
8

9
A a;
10

11
void B::f()  // B 的成员函数定义
12
{
13
    operator+(a, a);  // 错误：在成员函数中的常规名字查找
14
                      // 找到了 B 的作用域中的 operator+ 的声明
15
                      // 并于此停下，而不会达到全局作用域
16
    a + a;            // OK：成员查找找到了 B::operator+，非成员查找
17
                      // 找到了 ::operator+(A,A)，重载决议选中了 ::operator+(A,A)
18
}

1
struct special{};
2
namespace mystd{
3
    template<typename T>
4
    void foo(T t) {
5
        std::cout << "foo(T)" << std::endl;
6
    }
7
}
8

9
namespace yb {
10
    struct myclass {};
11
    void foo(myclass s) { std::cout << "yb::foo" << std::endl; }
12
}  // namespace yb
13

14
namespace xx {
15
    struct XA {};
16
    void foo(XA &a) { std::cout << "xx::foo" << std::endl; }
17
}  // namespace xx
18

19
namespace yy {
20
    void foo(int a) { std::cout << "yy::foo" << std::endl; }
21
    void test0() {
22
        xx::XA xa;
23
        foo(xa);  // 　一切正常
24
    }
25

26
    namespace zz {
27
        struct foo_callable {
28
            template <typename... Args>
29
            void operator()(Args &&...args) const {
30
                // using xx::foo;
31
                // using yb::foo;
32
                // using yy::foo;
33
                // 不用任何的using。因为我们传入的参数的namespace里都有一个叫foo的。所以正常ADL会找到的。
34
                using mystd::foo; // 这个using是模拟swap例子里的using。
35
                // 使用这个using的原因是mystd里面没有special这个成员。所以ADL也找不到。
36
                std::cout << "zz::foo" << std::endl;
37
                foo(std::forward<Args>(args)...);  // 正常ADL
38
            }
39
        };
40

41
        foo_callable foo{};  // 全局可用的CPO实例
42
    }  // namespace zz
43

44
    void test1() {
45
        using zz::foo;  // 由于该处声明，引入的是一个函数对象，则1处不会进行ADL，而是直接调用zz::foo
46
        xx::XA xa;
47
        yb::myclass s;
48
        foo(xa);  // 1
49
        foo(s);   // 2
50
        foo(10);  // 3
51
        foo(special{}); // 4
52
    }
53
}  // namespace yy
54

55
int main() {
56
    yy::test1();
57
    return 0;
58
}