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]

 

例7
这是一个现实中的例子，如果想给std::pair写一个ostream的输出函数，应该如何实现呢？

template<class U, class V>   
ostream& operator<<(ostream& s, const pair<U, V>& p)   
{   
    return s << p.first << " : " << p.second;   
}

差不多该这样吧