6.函数重载（重点）

1.函数重载是：允许函数名相同，这种现象叫函数重载

2.函数重载的作用：是为了方便使用函数名

3.函数重载的条件：同一个作用域，参数的个数不同，参数的顺序不同，参数的类型不同

//参数的个数不同
void func()
{
	cout << "func()" << endl;
}

void func(int a)
{
	cout << "func(int a)" << endl;
}

//参数的类型不同
void func(char c)
{
	cout << "func(char c)" << endl;
}
//参数的顺序不同
void func(int a, double b)
{
	cout << "func(int a, double b)" << endl;
}
void func(double b, int a)
{
	cout << "func(double b, int a)" << endl;
}

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

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

  函数的名字仅仅是让编译器知道它调用的是哪个函数，而函数重载可以在一定程度上减轻程序员起名字、记名字的负担。

4.调用重载函数的注意：

  严格的类型匹配，如果类型不匹配，那么尝试转换，转换成功就掉用，失败就报错

void test01()
{
	int a = 10;
	double b = 3.14;

	func();
	//func(b);// err double转换不了成为int或char
	func(a, b);
	func(b, a);
	char c = 'c';
	func(c);//char转换int成功，调用int参数的函数
}

5.函数重载和函数的默认参数一起使用，需要注意二义性问题

//函数重载和函的默认参数一起使用
void myfunc(int a, int b = 0)
{
	cout << "myfunc(int a, int b = 0)" << endl;
}

void myfunc(int a)
{
	cout << "myfunc(int a)" << endl;
}

void test02()
{
	//myfunc(10); err,二义性问题，不知道调用哪个函数
}

6.函数的返回值不作为函数重载的条件

  编译器是通过你调用函数时，传入的参数来判断调用重载的哪个函数，我们调研函数时不需要写返回值，所以返回值不能成为函数重载的条件

7.重载和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(); 

8.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 &sl, string &s2) 
{
    auto &r = shorterString(const_cast<const string&>(s1), const_cast<const string&>(s2));
    return const_cast<string&>(r); 
}

  在这个版本的函数中，首先将它的实参强制转换成对const的引用，然后调用了 shorterString函数的const版本。const版本返回对cpnst string的引用，这一个引用事实上绑定在了某个初始的非常量实参上。因此，我们可以再将其转换回一个普通的string &，这显然是安全的。

9.调用重载的函数

  定义了一组重载函数后，我们需要以合理的实参调用它们。函数匹配(function matching)是指一个过程，在这个过程中我们把函数调用与一组重载函数中的某一个关联起来，函数匹配也叫做重载确定(overload resolution)。编译器首先将调用的实参与重载集合中每一个函数的形参进行比较，然后根据比较的结果决定到底调用哪个函数。在很多（可能是大多数）情况下，程序员很容易判断某次调用是否合法，以及当调用合法时应该调用哪个函数。通常，重载集中的函数区别明显，它们要不然是参数的数量不同，要不就是参数类型亳无关系。此时，确定调用哪个函数比较容易。但是在另外一些情况下要想选择函数就比较困难了，比如当两个重载函数参数数量相同且参数类型可以相互转换时（第4.11节，141页）。我们将在6.6节（第217页）介绍当函数调用存在类型转换时编译器处理的方法 。

现在 我们需要掌握的是， 当调用重载函数时有三种可能的结果：

●编译器找到一个与实参最佳匹配(best match)的函数，并生成调用该函数的代码。

●找不到任何一个函数与调用的实参匹配，此时编译器发出无匹配(no match)的错误信息。

●有多于一个函数可以匹配，但是每一个都不是明显的最佳选择。此时也将发生错误，称为二义性调用(ambiguous call)。

10.重载与作用域

警告：

一般来说，将函数声明置于局部作用域内不是一个明智的选择。但是为了说明作用域和重载的相互关系，我们将暂时违反这一原则而使用局部函数声明。

  对于刚接触C+＋的程序员来说，不太容易理清作用域和重载的关系。其实，重载对作用域的般性质并没有什么改变：如果我们在内层作用域中声明名字，它将隐藏外层作用域中声明的同名实体。在不同的作用域中无法重载函数名：

string read(); 
void print(const string&); 
void print(double); //重载print函数
void fooBar(int ival) 
{
    bool read = false;//新作用域：隐藏了外层的read
    string s= 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值的那个局部声明。一旦在当前作用域中找到了所需的名字，编译器就会忽略掉外层作用域中的同名实体。剩下的工作就是检查函数调用是否有效了。

注意：

在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)
}

参考资料

参考资料来源于黑马程序员，C++ Primer等