第七章 函数(part6) 重载函数

出现在相同作用域中的两个函数，如果具有相同的名字而形参表不同，则称为重载函数。

使用某种程序设计语言编写过算术表达式的程序员都肯定使用过重载函数。表达式

 1+3

调用了针对整型操作数加法操作符，而表达式

     1.0 + 3.0

调用了另外一个专门处理浮点操作数的不同的加法操作。根据操作数的类型来区分不同的操作，并应用适当的操作，是编译器的责任，而不是程序员的事情。

类似地，程序员可以定义一组函数，它们执行同样的一般性动作，但是应用在不同的形参类型上，调用这些函数时，无需担心调用的是哪个函数，就像我们不必操心执行的是整数算术操作还是浮点数自述操作就可以实现int 型加法或double 型加法一样。

通过省去为函数起名并记住函数名字的麻烦，函数重载简化了程序的实现，使程序更容易理解。函数名只是为了帮助编译器判断调用的是哪个函数而已。

例如，一个数据库应用可能需要提供多个 lookup 函数，分别实现基于姓名、电话号码或账号之类的查询功能。函数重载使我们可以定义一系列的函数，它们的名字都是lookup，不同之处在于用于查询的值不相同。如此可传递几种类型中的任一种值调用lookup 函数：

     Record lookup(const Account&);  // find by Account     Record lookup(const Phone&);    // find by Phone     Record lookup(const Name&);     // find by Name     Record r1, r2;     r1 = lookup(acct);                  // call version that takes an Account     r2 = lookup(phone);                 // call version that takes a Phone

这里的三个函数共享同一个函数名，但却是三个不同的函数。编译器将根据所传递的实参类型来判断调用的是哪个函数。

要理解函数重载，必须理解如何定义一组重载函数和编译器如何决定对某一调用使用哪个函数。本节的其余部分将会回顾这些主题。

<Note>:

任何程序都仅有一个 main 函数的实例。main 函数不能重载。

函数重载和重复声明的区别

如果两个函数声明的返回类型和形参表完全匹配，则将第二个函数声明视为第一个的重复声明。如果两个函数的形参表完全相同，但返回类型不同，则第二个声明是错误的：

     Record lookup(const Account&);     bool lookup(const Account&); // error: only return type is different

函数不能仅仅基于不同的返回类型而实现重载。

有些看起来不相同的形参表本质上是相同的：

     // each pair declares the same function     Record lookup(const Account &acct);     Record lookup(const Account&); // parameter names are ignored     typedef Phone Telno;     Record lookup(const Phone&);     Record lookup(const Telno&); // Telno and Phone are the same type     Record lookup(const Phone&, const Name&);     // default argument doesn't change the number of parameters     Record lookup(const Phone&, const Name& = "");     // const is irrelevent for nonreference parameters     Record lookup(Phone);     Record lookup(const Phone); // redeclaration

在第一对函数声明中，第一个声明给它的形参命了名。形参名只是帮助文档，并没有修改形参表。

在第二对函数声明中，看似形参类型不同，但注意到 Telno 其实并不是新类型，只是 Phone 类型的同义词。typedef 给已存在的数据类型提供别名，但并没有创建新的数据类型。所以，如果两个形参的差别只是一个使用typedef 定义的类型名，而另一个使用typedef 对应的原类型名，则这两个形参并无不同。

在第三对中，形参列表只有默认实参不同。默认实参并没有改变形参的个数。无论实参是由用户还是由编译器提供的，这个函数都带有两个实参。

最后一对的区别仅在于是否将形参定义为 const。这种差异并不影响传递至函数的对象；第二个函数声明被视为第一个的重复声明。

其原因在于实参传递的方式。复制形参时并不考虑形参是否为 const——函数操纵的只是副本。函数的无法修改实参。

结果，既可将 const 对象传递给 const 形参，也可传递给非 const 形参，这两种形参并无本质区别。

值得注意的是，形参与 const 形参的等价性仅适用于非引用形参。有 const 引用形参的函数与有非const 引用形参的函数是不同的。

类似地，如果函数带有指向 const 类型的指针形参，则与带有指向相同类型的非 const 对象的指针形参的函数不相同。

建议：何时不重载函数名

虽然，对于通常的操作，重载函数能避免不必要的函数命名（和名字记忆），但很容易就会过分使用重载。在一些情况下，使用不同的函数名能提供较多的信息，使程序易于理解。考虑下面Screen 类的一组用于移动屏幕光标的成员函数：

     Screen& moveHome();     Screen& moveAbs(int, int);     Screen& moveRel(int, int, char *direction);

乍看上去，似乎把这组函数重载为名为 move 的函数更好一些：

     Screen& move();     Screen& move(int, int);     Screen& move(int, int, *direction);

其实不然，重载过后的函数失去了原来函数名所包含的信息，如此一来，程序变得晦涩难懂了。

虽则这几个函数共享的一般性动作都是光标移动，但特殊的移动性质却互不相同。例如，moveHome 表示的是光标移动的一个特殊实例。对于程序的读者，下面两种调用中，哪种更易于理解？而对于使用Screen 类的程序员，哪一个调用又更容易记忆呢？

     // which is easier to understand?     myScreen.home(); // we think this one!     myScreen.move();

7.8.1. 重载与作用域

演示了 C++ 作用域的嵌套。在函数中局部声明的名字将屏蔽在全局作用域内声明的同名名字。这个关于变量名字的性质对于函数名同样成立：

     /* Program for illustration purposes only:      * It is bad style for a function to define a local variable      * with the same name as a global name it wants to use      */     string init(); // the name init has global scope     void fcn()     {         int init = 0;        // init is local and hides global init         string s = init();   // error: global init is hidden     }

一般的作用域规则同样适用于重载函数名。如果局部地声明一个函数，则该函数将屏蔽而不是重载在外层作用域中声明的同名函数。由此推论，每一个版本的重载函数都应在同一个作用域中声明。

<Beware>:

一般来说，局部地声明函数是一种不明智的选择。函数的声明应放在头文件中。

但为了解释作用域与重载的相互作用，我们将违反上述规则而使用局部函数声明。

作为例子，考虑下面的程序：

     void print(const string &);     void print(double);   // overloads the print function     void fooBar(int ival)     {         void print(int);   // new scope: hides previous instances of print         print("Value: ");  // error: print(const string &) is hidden         print(ival); // ok: print(int) is visible         print(3.14); // ok: calls print(int); print(double) is hidden     }

函数 fooBar 中的 print(int) 声明将屏蔽 print 的其他声明，就像只有一个有效的 print 函数一样：该函数仅带有一个 int 型形参。在这个作用域或嵌套在这个作用域里的其他作用域中，名字 print 的任何使用都将解释为这个print 函数实例。

调用 print 时，编译器首先检索这个名字的声明，找到只有一个 int 型形参的 print 函数的局部声明。一旦找到这个名字，编译器将不再继续检查这个名字是否在外层作用域中存在，即编译器将认同找到的这个声明即是程序需要调用的函数，余下的工作只是检查该名字的使用是否有效。

第一个函数调用传递了一个字符串字面值，但是函数的形参却是 int 型的。字符串字面值无法隐式地转换为 int 型，因而该调用是错误的。print(const string&) 函数与这个函数调用匹配，但已被屏蔽，因此不在解释该调用时考虑。

当传递一个 double 数据调用 print 函数时，编译器重复了同样的匹配过程：首先检索到print(int) 局部声明，然后将double 型的实参隐式转换为int 型。因此，该调用合法。

<Note>:

在 C++ 中，名字查找发生在类型检查之前。

另一种情况是，在与其他 print 函数相同的作用域中声明 print(int)，这样，它就成为print 函数的另一个重载版本。此时，所有的调用将以不同的方式解释：

     void print(const string &);     void print(double); // overloads print function     void print(int);    // another overloaded instance     void fooBar2(int ival)     {         print("Value: "); // ok: calls print(const string &)         print(ival);      // ok: print(int)         print(3.14);      // ok: calls print (double)     }

现在，编译器在检索名字 print 时，将找到这个名字的三个函数。每一个调用都将选择与其传递的实参相匹配的print 版本。

7.8.2. 函数匹配与实参转换

函数重载确定，即函数匹配是将函数调用与重载函数集合中的一个函数相关联的过程。通过自动提取函数调用中实际使用的实参与重载集合中各个函数提供的形参做比较，编译器实现该调用与函数的匹配。匹配结果有三种可能：

1. 编译器找到与实参最佳匹配的函数，并生成调用该函数的代码。

2. 找不到形参与函数调用的实参匹配的函数，在这种情况下，编译器将给出编译错误信息。

3. 存在多个与实参匹配的函数，但没有一个是明显的最佳选择。这种情况也是，该调用具有二义性。

大多数情况下，编译器都可以直接明确地判断一个实际的调用是否合法，如果合法，则应该调用哪一个函数。

重载集合中的函数通常有不同个数的参数或无关联的参数类型。当多个函数的形参具有可通过隐式转换关联起来的类型，则函数匹配将相当灵活。

在这种情况下，需要程序员充分地掌握函数匹配的过程。

7.8.3. 重载确定的三个步骤

考虑下面的这组函数和函数调用：

     void f();     void f(int);     void f(int, int);     void f(double, double = 3.14);     f(5.6);  // calls void f(double, double)

候选函数

函数重载确定的第一步是确定该调用所考虑的重载函数集合，该集合中的函数称为候选函数。候选函数是与被调函数同名的函数，并且在调用点上，它的声明可见。在这个例子中，有四个名为f 的候选函数。

选择可行函数

第二步是从候选函数中选择一个或多个函数，它们能够用该调用中指定的实参来调用。因此，选出来的函数称为可行函数。

可行函数必须满足两个条件：第一，函数的形参个数与该调用的实参个数相同；第二，每一个实参的类型必须与对应形参的类型匹配，或者可被隐式转换为对应的形参类型。

<Beware>:

如果函数具有默认实参，则调用该函数时，所用的实参可能比实际需要的少。默认实参也是实参，在函数匹配过程中，它的处理方式与其他实参一样。

对于函数调用 f(5.6)，可首先排除两个实参个数不匹配的候选函数。没有形参的 f 函数和有两个int 型形参的f 函数对于这个函数调用来说都不可行。

例中的调用只有一个实参，而这些函数分别带有零个和两个形参。

另一方面，有两个 double 型参数的 f 函数可能是可行的。调用带有默认实参的函数时可忽略这个实参。编译器自动将默认实参的值提供给被忽略的实参。

因此，某个调用拥有的实参可能比显式给出的多。

根据实参个数选出潜在的可行函数后，必须检查实参的类型是否与对应的形参类型匹配。与任意函数调用一样，实参必须与它的形参匹配，它们的类型要么精确匹配，要么实参类型能够转换为形参类型。在这个例子中，余下的两个函数都是是可行的。

• f(int) 是一个可行函数，因为通过隐式转换可将函数调用中的 double 型实参转换为该函数唯一的int 型形参。

• f(double, double) 也是一个可行函数，因为该函数为其第二个形参提供了默认实参，而且第一个形参是double 类型，与实参类型精确匹配。

<Note>:

如果没有找到可行函数，则该调用错误。

寻找最佳匹配（如果有的话）

函数重载确定的第三步是确定与函数调用中使用的实际参数匹配最佳的可行函数。这个过程考虑函数调用中的每一个实参，选择对应形参与之最匹配的一个或多个可行函数。这里所谓“最佳”的细节将在下一节中解释，其原则是实参类型与形参类型越接近则匹配越佳。因此，实参类型与形参类型之间的精确类型匹配比需要转换的匹配好。

在上述例子中，只需考虑一个 double 类型的显式实参。如果调用 f(int)，实参需从double 型转换为int 型。而另一个可行函数f(double, double) 则与该实参精确匹配。

由于精确匹配优于需要类型转换的匹配，因此编译器将会把函数调用 f(5.6) 解释为对带有两个 double 形参的f 函数的调用。

含有多个形参的重载确定

如果函数调用使用了两个或两个以上的显式实参，则函数匹配会更加复杂。假设有两样的名为 f 的函数，分析下面的函数调用：

     f(42, 2.56);

可行函数将以同样的方式选出。编译器将选出形参个数和类型都与实参匹配的函数。在本例中，可行函数是 f(int, int) 和f(double, double)。接下来，编译器通过依次检查每一个实参来决定哪个或哪些函数匹配最佳。如果有且仅有一个函数满足下列条件，则匹配成功：

1. 其每个实参的匹配都不劣于其他可行函数需要的匹配。

2. 至少有一个实参的匹配优于其他可行函数提供的匹配。

如果在检查了所有实参后，仍找不到唯一最佳匹配函数，则该调用错误。编译器将提示该调用具有二义性。

在本例子的调用中，首先分析第一个实参，发现函数 f(int, int) 匹配精确。如果使之与第二个函数匹配，就必须将int 型实参42 转换为double 型的值。通过内置转换的匹配“劣于”精确匹配。所以，如果只考虑这个形参，带有两个int 型形参的函数比带有两个double 型形参的函数匹配更佳。

但是，当分析第二个实参时，有两个 double 型形参的函数为实参 2.56 提供了精确匹配。而调用两个 int 型形参的f 函数版本则需要把2.56 从double 型转换为 int 型。所以只考虑第二个形参的话，函数f(double, double) 匹配更佳。

因此，这个调用有二义性：每个可行函数都对函数调用的一个实参实现更好的匹配。编译器将产生错误。解决这样的二义性，可通过显式的强制类型转换强制函数匹配：

     f(static_cast<double>(42), 2.56);  // calls f(double, double)     f(42, static_cast<int>(2.56));     // calls f(int, int)

在实际应用中，调用重载函数时应尽量避免对实参做强制类型转换：需要使用强制类型转换意味着所设计的形参集合不合理。

7.8.4. 实参类型转换

为了确定最佳匹配，编译器将实参类型到相应形参类型转换划分等级。转换等级以降序排列如下：

1. 精确匹配。实参与形参类型相同。

2. 通过类型提升实现的匹配（第 5.12.2 节）。

3. 通过标准转换实现的匹配（第 5.12.3 节）。

4. 通过类类型转换实现的匹配（第 14.9 节将介绍这类转换）。

<Note>:

内置类型的提升和转换可能会使函数匹配产生意想不到的结果。但幸运的是，设计良好的系统很少会包含与下面例子类似的形参类型如此接近的函数。

需要类型提升或转换的匹配

类型提升或转换适用于实参类型可通过某种标准转换提升或转换为适当的形参类型情况。

必须注意的一个重点是较小的整型提升为 int 型。假设有两个函数，一个的形参为 int 型，另一个的形参则是short 型。对于任意整型的实参值，int 型版本都是优于short 型版本的较佳匹配，即使从形式上看short 型版本的匹配较佳：

     void ff(int);     void ff(short);     ff('a');    // char promotes to int, so matches f(int)

字符字面值是 char 类型，char 类型可提升为 int 型。提升后的类型与函数 ff(int) 的形参类型匹配。char 类型同样也可转换为short 型，但需要类型转换的匹配“劣于”需要类型提升的匹配。结果应将该调用解释为对ff (int) 的调用。

通过类型提升实现的转换优于其他标准转换。例如，对于 char 型实参来说，有 int 型形参的函数是优于有double 型形参的函数的较佳匹配。其他的标准转换也以相同的规则处理。例如，从char 型到unsigned char 型的转换的优先级不比从char 型到 double 型的转换高。再举一个具体的例子，考虑：

     extern void manip(long);     extern void manip(float);     manip(3.14);  // error: ambiguous call

字面值常量 3.14 的类型为 double。这种类型既可转为 long 型也可转为 float 型。由于两者都是可行的标准转换，因此该调用具有二义性。没有哪个标准转换比其他标准转换具有更高的优先级。

参数匹配和枚举类型

回顾枚举类型 enum，我们知道这种类型的对象只能用同一枚举类型的另一个对象或一个枚举成员进行初始化（第 2.7 节）。整数对象即使具有与枚举元素相同的值也不能用于调用期望获得枚举类型实参的函数。

     enum Tokens {INLINE = 128, VIRTUAL = 129};     void ff(Tokens);     void ff(int);     int main() {         Tokens curTok = INLINE;         ff(128);    // exactly matches ff(int)         ff(INLINE); // exactly matches ff(Tokens)         ff(curTok); // exactly matches ff(Tokens)         return 0;     }

传递字面值常量 128 的函数调用与有一个 int 型参数的 ff 版本匹配。

虽然无法将整型值传递给枚举类型的形参，但可以将枚举值传递给整型形参。此时，枚举值被提升为 int 型或更大的整型。具体的提升类型取决于枚举成员的值。如果是重载函数，枚举值提升后的类型将决定调用哪个函数：

     void newf(unsigned char);     void newf(int);     unsigned char uc = 129;     newf(VIRTUAL); // calls newf(int)     newf(uc);      // calls newf(unsigned char)

枚举类型 Tokens 只有两个枚举成员，最大的值为 129。这个值可以用 unsigned char 类型表示，很多编译器会将这个枚举类型存储为unsigned char 类型。然而，枚举成员VIRTUAL 却并不是unsigned char 类型。就算枚举成员的值能存储在unsigned char 类型中，枚举成员和枚举类型的值也不会提升为unsigned char 类型。

<Beware>:

在使用有枚举类型形参的重载函数时，请记住：由于不同枚举类型的枚举常量值不相同，在函数重载确定过程中，不同的枚举类型会具有完全不同的行为。其枚举成员决定了它们提升的类型，而所提升的类型依赖于机器。

重载和 const 形参

仅当形参是引用或指针时，形参是否为 const 才有影响。

可基于函数的引用形参是指向 const 对象还是指向非 const 对象，实现函数重载。将引用形参定义为const 来重载函数是合法的，因为编译器可以根据实参是否为const 确定调用哪一个函数：

     Record lookup(Account&);     Record lookup(const Account&); // new function     const Account a(0);     Account b;     lookup(a);   // calls lookup(const Account&)     lookup(b);   // calls lookup(Account&)

如果形参是普通的引用，则不能将 const 对象传递给这个形参。如果传递了 const 对象，则只有带const 引用形参的版本才是该调用的可行函数。

如果传递的是非 const 对象，则上述任意一种函数皆可行。非 const 对象既可用于初始化const 引用，也可用于初始化非const 引用。但是，将const 引用初始化为非 const 对象，需通过转换来实现，而非const 形参的初始化则是精确匹配。

对指针形参的相关处理如出一辙。可将 const 对象的地址值只传递给带有指向 const 对象的指针形参的函数。

也可将指向非 const 对象的指针传递给函数的 const 或非 const 类型的指针形参。

如果两个函数仅在指针形参时是否指向 const 对象上不同，则指向非 const 对象的指针形参对于指向非const 对象的指针（实参）来说是更佳的匹配。

重复强调，编译器可以判断：如果实参是 const 对象，则调用带有 const* 类型形参的函数；否则，如果实参不是const 对象，将调用带有普通指针形参的函数。

注意不能基于指针本身是否为 const 来实现函数的重载：

     f(int *);     f(int *const); // redeclaration

此时，const 用于修改指针本身，而不是修饰指针所指向的类型。

在上述两种情况中，都复制了指针，指针本身是否为 const 并没有带来区别。

正如前面所提到的，当形参以副本传递时，不能基于形参是否为 const 来实现重载。