C++Primer学习（6.4 函数重载）

6.4 函数重载
如果同一作用域内的几个函数名字相同但形参列表不同，我们称之为重载(over loaded)函数。例如，在6.2.4节(第193页)中我们定义了几个名为print 的函数:

void print(const char *cp);
void print(const int *beg,const int *end);
void print(const int ia1[],size_t size);

这些函数接受的形参类型不一样，但是执行的操作非常类似。当调用这些函数时，编译器会根据传递的实参类型推断想要的是哪个函数:

int j[2]=(0,1};
print("Hello World");//调用 print(const char*)
print(j,end(j)-begin(j));//调用print(const int*，size t)
print(begin(j),end(j));//调用print(const int*，const int*)

函数的名字仅仅是让编译器知道它调用的是哪个函数，而函数重载可以在一定程度上减轻程序员起名字、记名字的负担。
Note:main 函数不能重载。
定义重载函数
有一种典型的数据库应用，需要创建几个不同的函数分别根据名字、电话、账户号码等信息查找记录。函数重载使得我们可以定义一组函数，它们的名字都是lookup，但是查找的依据不同。我们能通过以下形式中的任意一种调用lookup函数:

Record lookup(const Account&);//根据Account 查找记录
Record lookup(const Phone&);//根据 Phone 查找记录
Record lookup(const Name&);//根据Name 查找记录
Accountat;
Phone phone;
Record rl=lookup(acct);//调用接受Account的版本
Record r2=lookup(phone);//调用接受Phone 的版本

其中，虽然我们定义的三个函数各不相同，但它们都有同一个名字。编译器根据实参的类型确定应该调用哪一个函数。
对于重载的函数来说,它们应该在形参数量或形参类型上有所不同。在上面的代码中,虽然每个函数都只接受一个参数，但是参数的类型不同。
不允许两个函数除了返回类型外其他所有的要素都相同。假设有两个函数，它们的形参列表一样但是返回类型不同，则第二个函数的声明是错误的:

Record lookup(constAccount&);
bool lookup(const Account&);//错误:与上一个函数相比只有返回类型不同

判断两个形参的类型是否相异
有时候两个形参列表看起来不一样，但实际上是相同的:

//每对声明的是同一个函数
Record lookup(constAccount &acct);
Record lookup(constAccount&);//省略了形参的名字
typedef Phone Telno;
Record lookup(const Phone&);
Record lookup(const Telno&);//Telno和Phone 的类型相同

在第一对声明中，第一个函数给它的形参起了名字，第二个函数没有。形参的名字仅仅起到帮助记忆的作用，有没有它并不影响形参列表的内容。
第二对声明看起来类型不同，但事实上Telno不是一种新类型，它只是 Phone 的别名而已。类型别名(参见2.5.1节，第60页)为已存在的类型提供另外一个名字，它并不是创建新类型。因此，第二对中两个形参的区别仅在于一个使用类型原来的名字，另一个使用它的别名，从本质上来说它们没什么不同。
重载和 const 形参
如6.2.3节(第190页)介绍的，顶层const(参见2.4.3节，第57页)不影响传入函数的对象。一个拥有顶层const的形参无法和另一个没有顶层const的形参区分开来:

Record lookup(Phone);
Record lookup(const Phone);//重复声明了Record lookup(Phone);
Record lookup(Phone*);
Record lookup(Phone* const);//重复声明了Record lookup(Phone*)

在这两组函数声明中，每一组的第二个声明和第一个声明是等价的。
另一方面，如果形参是某种类型的指针或引用，则通过区分其指向的是常量对象还是非常量对象可以实现函数重载，此时的const是底层的:

//对于接受引用或指针的函数来说，对象是常量还是非常量对应的形参不同
//定义了4个独立的重载函数
Record lookup(Account&);//函数作用于account的引用
Record lookup(const Account&);//新函数，作用于常量引用
Record lookup(Account*);//新函数，作用于指向Account 的指针
Record lookup(const Account*);//新函数，作用于指向常量的指针

在上面的例子中，编译器可以通过实参是否是常量来推断应该调用哪个函数。因为const不能转换成其他类型(参见4.11.2节，第144页)，所以我们只能把const对象(或指向const的指针)传递给const形参。相反的，因为非常量可以转换成const，所以上面的4个函数都能作用于非常量对象或者指向非常量对象的指针。不过，如6.6.1节(第220页)将要介绍的，当我们传递一个非常量对象或者指向非常量对象的指针时，编译器会优先选用非常量版本的函数。
建议:何时不应该重载函数
尽管函数重载能在一定程度上减轻我们为函数起名字、记名字的负担，但是最好只重载那些确实非常相似的操作。有些情况下,给函数起不同的名字能使得程序更易理解举个例子，下面是几个负责移动屏幕光标的函数:

Screen& moveHome();
Screen& moveAbs(int，int):
Screen& moveRel(int,int,string direction);

乍看上去，似乎可以把这组函数统一命名为move，从而实现函数的重载:

Screen& move();
Screen& move(int，int);
Screen& move(int,int,string direction)

其实不然，重载之后这些函数失去了名字中本来拥有的信息。尽管这些函数确实都是在移动光标，但是具体移动的方式却各不相同。以moveHome 为例，它表示的是移动光标的一种特殊实例。一般来说，是否重载函数要看哪个更容易理解:

//哪种形式更容易理解呢?
myScreen.moveHome();//我们认为应该是这一个!
myScreen.move();

const_cast 和重载
在4.11.3节(第145页)中我们说过，const_cast在重载函数的情景中最有用。举个例子，回忆6.3.2节(第201页)的shorterstring 函数:
//比较两个string对象的长度，返回较短的那个引用

const string &shorterString(const string &s1,const string &s2)
{
	return s1.size()<=s2.size()?s1:s2;
}

这个函数的参数和返回类型都是const string的引用。我们可以对两个非常量的string 实参调用这个函数，但返回的结果仍然是const string的引用。因此我们需要一种新的 shorterstring函数，当它的实参不是常量时，得到的结果是一个普通的引用，使用const_cast可以做到这一点:

string &shorterString(string &s1,string &s2)
{
	auto &r=shorterString(const cast<const string&>(s1),const cast<const string&>(s2));
	return constcast<string&>(r);
}

在这个版本的函数中，首先将它的实参强制转换成对const的引用，然后调用了shorterString函数的const版本。const版本返回对const string的引用，这个引用事实上绑定在了某个初始的非常量实参上。因此，我们可以再将其转换回一个普通的string&，这显然是安全的。
调用重载的函数
定义了一组重载函数后，我们需要以合理的实参调用它们。函数匹配(function matching)是指一个过程，在这个过程中我们把函数调用与一组重载函数中的某一个关联起来，函数匹配也叫做重载确定(overload resolution)。编译器首先将调用的实参与重载集合中每一个函数的形参进行比较，然后根据比较的结果决定到底调用哪个函数。
在很多(可能是大多数)情况下，程序员很容易判断某次调用是否合法，以及当调用合法时应该调用哪个函数。通常，重载集中的函数区别明显，它们要不然是参数的数量不同，要不就是参数类型毫无关系。此时，确定调用哪个函数比较容易。但是在另外一些情况下要想选择函数就比较困难了，比如当两个重载函数参数数量相同且参数类型可以相互转换时(第4.11节，141页)。我们将在6.6节(第217页)介绍当函数调用存在类型转换时编译器处理的方法。
现在我们需要掌握的是，当调用重载函数时有三种可能的结果:
1)编译器找到一个与实参最佳匹配(best match)的函数，并生成调用该函数的代码。
2)找不到任何一个函数与调用的实参匹配，此时编译器发出无匹配(no match)的错误信息。
3)有多于一个函数可以匹配,但是每一个都不是明显的最佳选择。此时也将发生错误,称为二义性调用(ambiguous call)。
6.4.1重载与作用域
WARNING：一般来说，将函数声明置于局部作用域内不是一个明智的选择。但是为了说明作用域和重载的相互关系，我们将暂时违反这一原则而使用局部函数声明。
对于刚接触C++的程序员来说，不太容易理清作用域和重载的关系。其实，重载对作用域的一般性质并没有什么改变:如果我们在内层作用域中声明名字，它将隐藏外层作用域中声明的同名实体。在不同的作用域中无法重载函数名:

string read();
void print(const string &);
void print(double);//重载print 函数
void fooBar(int ival)
{
	bool read =false;//新作用域:隐藏了外层的read
	strings=read();//错误:read是一个布尔值，而非函数
	//不好的习惯:通常来说，在局部作用域中声明函数不是一个好的选择
	void print(int);//新作用域:隐藏了之前的print
	print("Value:");//错误:print(const string &)被隐藏掉了
	print(ival);//正确:当前print(int)可见
	print(3.14);//正确:调用print(int);print(double)被隐藏掉了
}

大多数读者都能理解调用read 函数会引发错误。因为当编译器处理调用read 的请求时找到的是定义在局部作用域中的read。这个名字是个布尔变量，而我们显然无法调用一个布尔值，因此该语句非法。调用 print 函数的过程非常相似。在 fooBar 内声明的print(int)隐藏了之前两个print函数，因此只有一个print函数是可用的:该函数以int值作为参数。
当我们调用print函数时，编译器首先寻找对该函数名的声明，找到的是接受int值的那个局部声明。一旦在当前作用域中找到了所需的名字，编译器就会忽略掉外层作用域中的同名实体。剩下的工作就是检查函数调用是否有效了。
Note：在C++语言中，名字查找发生在类型检查之前。
第一个调用传入一个字符串字面值，但是当前作用域内print函数唯一的声明要求参数是int类型。字符串字面值无法转换成int类型，所以这个调用是错误的。在外层作用域中的print(const string&)函数虽然与本次调用匹配,但是它已经被隐藏掉了，根本不会被考虑。
当我们为 print函数传入一个 double 类型的值时，重复上述过程。编译器在当前作用域内发现了 print(int)函数，double类型的实参转换成int类型，因此调用是合法的。
假设我们把 print(int)和其他print函数声明放在同一个作用域中，则它将成为另一种重载形式。此时,因为编译器能看到所有三个函数,上述调用的处理结果将完全不同:

void print(const string &);
void print(double);//print 函数的重载形式
void print(int);//print函数的另一种重载形式
void fooBar2(int ival)
{
	print("Value:");	//调用print(const string &)
	print(ival);	//调用print(int)
	print(3.14);	//调用 print(double)
}