1。符号查找（对于函数此时只看名字，不看参数）
大致顺序是
(1)如果有限定名( XXX:: )那么就直接在XXX里查找
(2)函数局部名字空间
(3)(如果是成员)类名字空间
(4)递归向上至所有基类的名字空间
(5)当前名字空间
(6)递归向外至所有外层名字空间,
在任一层里, 用using导入的符号和该层的其他符号同一对待。
keonig查找: 对于函数, 如果参数为类/结构/模版类并位于其他的名字空间,
在(5)和(6)的查找中导入该空间(不递归向外)的符号一同查找.
2。（如果是函数）重载决议（注意此时特化的函数不参与决议）
3。（如果是类内部的名字）检查访问权（注意此时特化的函数仍然不参与决议）
4。（如果找到了一个模版）模版特化决议
编译器执行以上步骤的时候是使用贪心匹配，只要找到一个符合当前检查内容的就会停止查
找
所以任何一层都有可能发生错误的掩盖情况
例1
1
void
f(
int
)
{}
2
class
Y
3
{
4
public
:
5
void
f()
{}
6
Y()
7
{
8
f(
1
);
9
}
10
}
;
这里的f(2)在1.(2)这里找到了符号f，就不会向上到1.(5)查找到真正的f(int)了
例2
void
g(
int
)
{}
namespace
S
{
void
g()
{}
void
h()
{
g(
1
);
}
}
这里的g(1)在1.(5)这里找到了符号g，就不会向上到1.(6)查找到真正的g(int)了
例3
class
Y
{
void
f(
int
)
{}
//
[1]
public
:
void
f(
double
)
{}
//
[2]
}
;
int
main()
{
Y y;
y.f(
1
);
}
y.f(1)会调用[2]吗？不会，因为在第2步重载决议的时候就选定[1]了，因此这段代码会报
出无法访问private成员的错误
例4
template
<
typename T
>
void
f(T)
{}
//
[1]
template
<
typename T
>
void
f(T
*
)
{}
//
[2]
template
<>
void
f
<
int
*>
(
int
*
)
{}
//
[3]
int
main()
{
int
*
p
=
0
;
f(p);
}
这里的f(p)会调用[3]吗？
不会，因为在进行到第二步重载决议的时候，只有[1]和[2]参与了重载决议，结果选择了
[2]，那么[1]的特化版本[3]当然就轮不到了。
例5
class
X
{
template
<
typename T
>
void
g()
{}
public
:
template
<>
void
g
<
int
>
()
{}
}
;
int
main()
{
X y;
y.g
<
int
>
();
}
这里首先第3步访问检查发现g为private（此时g的特化版本被直接无视了），所以即使
g<int>为public, 该段代码仍然不能够编译通过
例6
namespace
E
{
class
X
{}
;
void
f(X)
{}
//
[1]
}
void
f(E::X)
{}
//
[2]
class
X
{
public
:
void
f()
{}
//
[3]
void
g()
{
E::X x;
f(x);
//
[4]
}
}
;
[4]会调用那个呢? 在1.(3)里就确定了是[3],因此参数不匹配
如果注释掉[3]的f,那么由于koenig查找, 在1.(5)里[1]和[2]都会是平等的可选项
所以会出现二义性.
如果把namespace E改为class E, 把E中的f改为静态函数
由于koenig查找仅仅导入参数的名字空间, 因此[1]将不参与1.(5)的查找,
最终结果会是[2]