《C++ primer》学习笔记之三十三：function overload resolution之一寻找候选函数集合

1.寻找候选函数集合(Candidate Function Set)：这一步的判断条件只有一个，即是否同名。
函数调用肯定在另一个函数定义中：
void caller()
{
T t; //T为任意类型，可为内建类型
f(t); //找到函数f的定义
}
a)在caller中调用f前声明的同名函数：
比如：
namespace N
{
void f(char *); //f in namespace N
}

namespace N2
{
void f(char *); //f in namespace N
}

void caller()
{
using N::f； //using function declare
using namespace N2; //注意：using directive.这个与using declare不同，它不是函数声明，只是使namespace的成员在此处可见

void f(double); //function declare

T t;
f(t); //function call

void f(int); //function declare, not a candidate
}
候选集合为{ N::f(char *), f(double) }， 没有N2::f(char *)
这些函数会hidden在caller外面声明的同名函数，所以候选集合中就只这三个。
如果在这一步找到了候选函数，则不会再依下面的步骤去找其它的候选函数。
b)如果caller为类ClassType的成员函数，则到类ClassType中找同名的成员函数；如果没有找到，则到父类中找，找到了就不到父类中找。
这些成员函数也会hidden在类ClassType外定义的同名函数。
如果在这一步找到了候选函数，则不会再依下面的步骤去找其它的候选函数。

注意：如果在a),b)中找到候选函数，则不会再去找其它候选函数。但下面的几步则不会，每步都会执行。
c)在调用处可见的同名函数：
namespace N
{
void f(char *); //f in namespace N
}

void f(string); //f in global scope
using namespace N; //名字空间N内的成员在global scope内可见
void caller()
{
T t;
f(t); //function call
}

候选集合为{ f(char *), f(string) }

using 和 using namespace可以使名字空间内的成员在某个scope内可见。
d)函数的参数的类型为类T, 类T在名字空间NT中定义，则名字空间NT内可见（用using声明的也可以）的同名函数：
namespace NT
{
void f(long);
void f(float);
}

namespace NT2
{
class T{};

using namespace NT; //使namespace NT的成员在NT2中可见
void f(float); //这个与NT::f(float)造成“二义”

}

void caller()
{
NT2::T t;
f(t); //参数t的类型T在名字空间NT内定义
}

候选集合为：{ NT::f(long), NT::f(float), NT2::f(float) }
虽然f(float)在caller中不可见，但也会去名字空间NT中去找候选函数。

注意：当T为typedef重定义的类型时，应把T还原后考虑，比如：
namespace NT
{
class T{};

void f(T);
}

namespace NT2
{
typedef NT::T t_type; //t_type实际上是NT::T

void f(t_type);
}

void caller()
{
NT2::t_type t;
f(t); //参数t的类型实际上为NT::T，所以在名字空间NT内定义
}

候选集合为：{ NT::T }，没有NT2::T。
只有当参数的类型为类class时才会执行这条，或者为指向类的指针、类的引用、指向类的成员的指针。
当为int等内建类型时不会。

d2)作为d)的延伸：
会到类T的friend函数中找候选函数；
会到类T的基类所在的名字空间中去找候选函数；
namespace NT2
{
class Base{};

void f(Base);
}

namespace NT
{
class T : public NT2::Base
{
friend void f(T);
};

void f(float);
}

void caller()
{
NT::T t;
f(t); //参数t的类型T在名字空间NT内定义
}

候选集合为：{ f(Base), f(T), f(float) }

实际上，类T的friend函数在类所在的namespace中是可见的，既使该friend函数在T中定义.
比如：
namespace N
{
class T
{
friend void f(T) { cout << "friend of T" << endl; }
};

void g()
{
T t;
f(t); //ok. f在namespace N中可见
}

void f(T) {} //error。这个与T的friend函数f造成重复定义
}

d3) 如果函数有多个参数，则对每个参数都执行d)，d2).
注意：d),d2),d3)这几条叫：argument-dependent lookup
这几条使得程序不是太容易读懂，应该不是好的写法。

总结：a), b)步骤中找到了候选函数的话不会执行c), d),
这是所谓的local hidden global.想想看，在C语言中没有class和namespace, 只有local和global之分，namespace只是将C语言的global细分，而class是将local细分。所以在C++中函数scope和class scope会hidden 全局和namespace
c)这一步是最常见的，通常是调用全局函数，或者定义在namespace中的函数
d)这步很让人迷惑，特别是d2)、d3)。但是也很常见。编译找不到函数调用时，会说：identifier not found, even with argument-dependent lookup

找候选集合这一步最不直观，通常意想不到某个函数会在候选集合中而造成二义调用；或者想调用的函数不在候选集合中
直观点的做法是用scope符"::"直接指定某一个函数，编译器会在指定的scope内找候选集合，而不去执行abcd这几步。

如果候选集合为空，则编译器报错“identifier not found, even with argument-dependent lookup”