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]