函数匹配

函数匹配与实参转换

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

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

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

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 的候选函数。

选择可行函数

第二步是从候选函数中选择一个或多个函数， 它们能够用该调用中指定的实参来调用。因此，选出来的函数称为可行函数。可行函数必须满足两个条件：第一，函数的形参个数与该调用的实参个数相同；第二，每一个实参的类型必须与对应形参的类型匹配，或者可被隐式转换为对应的形参类型。

对于函数调用 f(5.6)，可首先排除两个实参个数不匹配的候选函数。没有形参的 f 函数和有两个 int 型形参的 f 函数对于这个函数调用来说都不可行。例中的调用只有一个实参，而这些函数分别带有零个和两个形参。

调用带有默认实参的函数时可忽略这个实参。编译器自动将默认实参的值提供给被忽略的实参。因此，某个调用拥有的实参可能比显式给出的多。

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

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

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

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

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

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

在上述例子中，只需考虑一个 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)

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

实参类型转换

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

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

2. 通过类型提升实现的匹配。

3. 通过标准转换实现的匹配。

4. 通过类类型转换实现的匹配。

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

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

必须注意的一个重点是较小的整型提升为 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) 的调用。

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

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

参数匹配和枚举类型

enum类型的对象只能用同一枚举类型的另一个对象或一个枚举成员进行初始化。整数对象即使具有与枚举元素相同的值也不能用于调用期望获得枚举类型实参的函数。

整数对象即使具有与枚举元素相 同的值也不能用于调用期望获得枚举类型实参的函数。

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。这个值可以用 unsignedchar 类型表示，很多编译器会将这个枚举类型存储为 unsigned char 类型。然而，枚举成员 VIRTUAL 却并不是 unsigned char 类型。

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

重载和 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 

转载于:https://www.cnblogs.com/xiaojianliu/articles/8981237.html