12-函数重载

8.4　函数重载

函数多态是C++在C语言的基础上新增的功能。默认参数让您能够使用不同数目的参数调用同一个函数，而函数多态（函数重载）让您能够使用多个同名的函数。术语“多态”指的是有多种形式，因此函数多态允许函数可以有多种形式。类似地，术语“函数重载”指的是可以有多个同名的函数，因此对名称进行了重载。这两个术语指的是同一回事，但我们通常使用函数重载。可以通过函数重载来设计一系列函数——它们完成相同的工作，但使用不同的参数列表。

重载函数就像是有多种含义的动词。例如，Piggy小姐可以在棒球场为家乡球队助威（root），也可以在地里种植（root）菌类作物。根据上下文可以知道在每一种情况下，root的含义是什么。同样，C++使用上下文来确定要使用的重载函数版本。

函数重载的关键是函数的参数列表——也称为函数特征标（function signature）。如果两个函数的参数数目和类型相同，同时参数的排列顺序也相同，则它们的特征标相同，而变量名是无关紧要的。C++允许定义名称相同的函数，条件是它们的特征标不同。如果参数数目和/或参数类型不同，则特征标也不同。例如，可以定义一组原型如下的print()函数：

void print(const char * str, int width); // #1
void print(double d, int width);         // #2
void print(long l, int width);           // #3
void print(int i, int width);            // #4
void print(const char *str);             // #5

使用print()函数时，编译器将根据所采取的用法使用有相应特征标的原型：

print("Pancakes", 15);       // use #1
print("Syrup");              // use #5
print(1999.0, 10);           // use #2
print(1999, 12);             // use #4
print(1999L, 15);            // use #3

例如，print(“Pancakes”, 15)使用一个字符串和一个整数作为参数，这与#1原型匹配。

使用被重载的函数时，需要在函数调用中使用正确的参数类型。例如，对于下面的语句：

unsigned int year = 3210;
print(year, 6);        // ambiguous call

print()调用与哪个原型匹配呢？它不与任何原型匹配！没有匹配的原型并不会自动停止使用其中的某个函数，因为C++将尝试使用标准类型转换强制进行匹配。如果#2原型是print()唯一的原型，则函数调用print(year, 6)将把year转换为double类型。但在上面的代码中，有3个将数字作为第一个参数的原型，因此有3种转换year的方式。在这种情况下，C++将拒绝这种函数调用，并将其视为错误。

一些看起来彼此不同的特征标是不能共存的。例如，请看下面的两个原型：

double cube(double x);
double cube(double & x);

您可能认为可以在此处使用函数重载，因为它们的特征标看起来不同。然而，请从编译器的角度来考虑这个问题。假设有下面这样的代码：

cout << cube(x);

参数x与double x原型和double &x原型都匹配，因此编译器无法确定究竟应使用哪个原型。为避免这种混乱，编译器在检查函数特征标时，将把类型引用和类型本身视为同一个特征标。

匹配函数时，要区分const和非const变量。请看下面的原型：

void dribble(char * bits);        // overloaded
void dribble (const char *cbits); // overloaded
void dabble(char * bits);         // not overloaded
void drivel(const char * bits);   // not overloaded

下面列出了各种函数调用对应的原型：

const char p1[20] = "How's the weather?";
char p2[20] = "How's business?";
dribble(p1);  // dribble(const char *);
dribble(p2);  // dribble(char *);
dabble(p1);   // no match
dabble(p2);   // dabble(char *);
drivel(p1);   // drivel(const char *);
drivel(p2);   // drivel(const char *);

dribble()函数有两个原型，一个用于const指针，另一个用于常规指针，编译器将根据实参是否为const来决定使用哪个原型。dabble()函数只与带非const参数的调用匹配，而drivel()函数可以与带const或非const参数的调用匹配。drivel()和dabble()之所以在行为上有这种差别，主要是由于将非const值赋给const变量是合法的，但反之则是非法的。

请记住，是特征标，而不是函数类型使得可以对函数进行重载。例如，下面的两个声明是互斥的：

long gronk(int n, float m);    // same signatures,
double gronk(int n, float m); // hence not allowed

因此，C++不允许以这种方式重载gronk()。返回类型可以不同，但特征标也必须不同：

long gronk(int n, float m);      // different signatures,
double gronk(float n, float m); // hence allowed

在本章稍后讨论过模板后，将进一步讨论函数匹配的问题。

重载引用参数

类设计和STL经常使用引用参数，因此知道不同引用类型的重载很有用。请看下面三个原型：

void sink(double & r1);       // matches modifiable lvalue
void sank(const double & r2); // matches modifiable or const lvalue, rvalue
void sunk(double && r3);      // matches rvalue

左值引用参数r1与可修改的左值参数（如double变量）匹配；const左值引用参数r2与可修改的左值参数、const左值参数和右值参数（如两个double值的和）匹配；最后，右值引用参数r3与左值匹配。注意到与r1或r3匹配的参数都与r2匹配。这就带来了一个问题：如果重载使用这三种参数的函数，结果将如何？答案是将调用最匹配的版本：

void staff(double & rs);        // matches modifiable lvalue
voit staff(const double & rcs); // matches rvalue, const lvalue
void stove(double & r1);        // matches modifiable lvalue
void stove(const double & r2);  // matches const lvalue
void stove(double && r3);       // matches rvalue

这让您能够根据参数是左值、const还是右值来定制函数的行为：

double x = 55.5;
const double y = 32.0;
stove(x);              // calls stove(double &)
stove(y);              // calls stove(const double &)
stove(x+y);            // calls stove(double &&)

如果没有定义函数stove(double &&)，stove(x+y)将调用函数stove(const double &)。