学习 C++ / 第 11.3 课

函数重载决议与歧义匹配

15 分钟阅读

在上一课 (11.2 -- 函数重载的区分方式),我们讨论了用来区分重载函数的函数属性。如果某个重载函数无法与同名的其他重载正确区分,编译器就会报错。

不过,拥有一组可区分的重载函数只是问题的一半。 发生函数调用时,编译器还必须确保能找到匹配的函数声明。

对于非重载函数(名称唯一的函数),只有一个函数可能匹配调用。该函数要么匹配(或经过类型转换后可以匹配),要么不匹配(并产生编译错误)。对于重载函数,可能有多个函数匹配同一个调用。由于一次调用只能解析到其中一个函数,编译器必须确定哪个重载函数是最佳匹配。将函数调用匹配到特定重载函数的过程称为 重载决议.

在函数实参与形参类型完全匹配的简单情况下,这通常很直接:

C++
#include <iostream>

void print(int x)
{
     std::cout << x << '\n';
}

void print(double d)
{
     std::cout << d << '\n';
}

int main()
{
     print(5); // 5 是 int,因此匹配 print(int)
     print(6.7); // 6.7 是 double,因此匹配 print(double)

     return 0;
}

但函数调用实参类型与所有重载函数的形参类型都不完全匹配时怎么办? 例如:

C++
#include <iostream>

void print(int x)
{
     std::cout << x << '\n';
}

void print(double d)
{
     std::cout << d << '\n';
}

int main()
{
     print('a'); // char 不匹配 int 或 double,会发生什么?
     print(5L); // long 不匹配 int 或 double,会发生什么?

     return 0;
}

没有精确匹配并不意味着找不到匹配——毕竟, char 或 long 可以隐式转换为 int 或 double。但每种情况下应该选择哪种转换?

本节将探讨编译器如何把函数调用匹配到特定的重载函数。

解析重载函数调用

调用重载函数时,编译器会按一系列规则判断哪个重载函数(如果有)是最佳匹配(下一节将介绍这些步骤)。

每一步中,编译器都会对调用实参应用一组不同的类型转换。每应用一种转换,编译器就检查是否有重载函数匹配。完成该步骤的所有转换和匹配检查后,会得到三种结果之一:

  • 找不到匹配函数。编译器进入序列中的下一步。
  • 找到一个匹配函数。该函数被视为最佳匹配,匹配过程结束,不再执行后续步骤。
  • 找到多个匹配函数。编译器会产生歧义匹配错误,稍后将进一步讨论。

如果遍历完整个序列仍找不到匹配,编译器会报告找不到与该调用匹配的重载函数。

参数匹配顺序

第 1 步:编译器尝试寻找精确匹配。 这分两个阶段。首先,编译器检查是否存在重载函数,使调用中的实参类型与重载函数的形参类型完全匹配。 例如:

C++
void foo(int)
{
}

void foo(double)
{
}

int main()
{
    foo(0);   // 与 foo(int) 完全匹配
    foo(3.4); // 与 foo(double) 完全匹配

    return 0;
}

因为 0 在函数调用中 foo(0) 是 int,编译器会查找是否声明了 foo(int) 重载。由于存在,编译器判断 foo(int) 是精确匹配。

其次,编译器会对函数调用实参应用一些平凡转换。平凡转换 是一组用于寻找匹配的特定转换规则,只改变类型而不改变值,包括:

  • 左值到右值转换
  • 限定符转换(例如从非 const 到 const)
  • 非引用到引用转换

例如:

C++
void foo(const int)
{
}

void foo(const double&) // double& 是 double 的引用
{
}

int main()
{
    int x { 1 };
    foo(x); // x 从 int 平凡转换为 const int

    double d { 2.3 };
    foo(d); // d 从 double 平凡转换为 const double&(从非引用到引用的转换)

    return 0;
}

在上面的示例中,我们调用了 foo(x), 其中 x 是一个 int。 编译器会直接把 x 从 int 转换为 const int, 从而匹配 foo(const int)。我们还调用了 foo(d), 其中 d 是一个 double。 编译器会直接把 d 从 double 转换为 const double&, 从而匹配 foo(const double&)。

相关内容

引用在课程中介绍: 12.3 -- 左值引用。

通过平凡转换得到的匹配视为精确匹配。因此下面的程序会产生歧义匹配:

C++
void foo(int)
{
}

void foo(const int&) // int& 是 int 的引用
{
}

int main()
{
    int x { 1 };
    foo(x); // 与 foo(int) 和 foo(const int&) 产生歧义匹配

    return 0;
}

第 2 步:如果找不到精确匹配,编译器会对实参应用数值提升来寻找匹配。 在课程(10.1 -- 隐式类型转换)中,我们介绍了某些窄整数和浮点类型可以自动提升为更宽类型,例如 int or double。 如果数值提升后找到匹配,函数调用就确定了。

例如:

C++
void foo(int)
{
}

void foo(double)
{
}

int main()
{
    foo('a');  // 提升后转换以匹配 foo(int)
    foo(true); // 提升后转换以匹配 foo(int)
    foo(4.5f); // 提升后转换以匹配 foo(double)

    return 0;
}

对于 foo('a'),因为上一步找不到 foo(char) 的精确匹配,编译器会将 char 'a' 提升为 int, 并查找匹配。这与 foo(int), 匹配,因此函数调用解析为 foo(int)。

第 3 步:如果数值提升没有找到匹配,编译器会应用数值转换来寻找匹配 (10.3 -- 数值转换)转换实参。

例如:

C++
#include <string> // for std::string

void foo(double)
{
}

void foo(std::string)
{
}

int main()
{
    foo('a'); // 'a' 转换以匹配 foo(double)

    return 0;
}

本例中,因为没有 foo(char) (精确匹配),也没有 foo(int) (提升匹配), 'a' 会进行数值转换为 double,并匹配 foo(double)。

关键要点

数值提升得到的匹配优先于数值转换得到的匹配。

第 4 步:如果数值转换没有找到匹配,编译器会尝试用户定义转换。虽然我们尚未介绍用户定义转换,但某些类型(例如类)可以定义可隐式调用的到其他类型的转换。 下面的示例用于说明这一点:

C++
// 还没有讲到类,如果看不懂这段内容不必担心
class X // 这里定义名为 X 的新类型
{
public:
    operator int() { return 0; } // 这是从 X 到 int 的用户定义转换
};

void foo(int)
{
}

void foo(double)
{
}

int main()
{
    X x; // 这里创建一个名为 x 的 X 类型对象
    foo(x); // x 使用从 X 到 int 的用户定义转换转为 int

    return 0;
}

在这个示例中,编译器首先检查是否存在与 foo(X) 的精确匹配。我们没有定义这样的重载。接着检查 x 是否可以数值提升,但不能。然后检查 x 也无法进行数值转换。最后,编译器会查找用户定义转换。 由于定义了从 X 到 int,编译器会将 X 转换为 int,以匹配 foo(int)。

应用用户定义转换后,编译器还可能应用额外的隐式提升或转换来寻找匹配。如果用户定义转换的目标类型是 char 而不是 int,编译器会先使用到 char 的用户定义转换,再将结果提升为 int 来完成匹配。

相关内容

类类型的用户定义转换(通过重载类型转换运算符)在课程中介绍: 21.11 -- 重载类型转换运算符。

进阶读者

类的构造函数也可以充当从其他类型到该类类型的用户定义转换,并可在此步骤中用于查找匹配函数。

第 5 步:如果用户定义转换没有找到匹配,编译器会寻找使用省略号的匹配函数。

相关内容

省略号在课程中介绍: 20.5 -- 省略号(以及为什么应避免使用)。

第 6 步:如果到此仍没有找到匹配,编译器会放弃,并报告找不到匹配函数。

歧义匹配

对于非重载函数,每次调用要么解析到一个函数,要么找不到匹配并产生编译错误:

C++
void foo()
{
}

int main()
{
     foo(); // 正确:找到匹配项
     goo(); // 编译错误:未找到匹配项

     return 0;
}

对于重载函数,还可能出现第三种结果: 歧义匹配 可能找到。 An 歧义匹配 当编译器在同一步中找到两个或更多可匹配的函数时,就会发生歧义匹配。此时编译器会停止匹配,并报告函数调用存在歧义。

由于每个重载函数必须彼此区分才能编译,你可能会疑惑为什么一次调用仍可能产生多个匹配。下面看一个例子:

C++
void foo(int)
{
}

void foo(double)
{
}

int main()
{
    foo(5L); // 5L 的类型是 long

    return 0;
}

由于字面量 5L 的类型是 long,编译器首先查找是否存在 foo(long),但没有找到。接着尝试数值提升,但 long 无法提升,因此这里也没有匹配。

随后,编译器会应用数值转换来为 long 实参寻找匹配。在检查所有数值转换规则时,编译器会找到两个潜在匹配:如果将 long 实参转换为 int,函数调用会匹配 foo(int);如果将 long 实参转换为 double,则会匹配 foo(double)。由于通过数值转换找到了两个可能的匹配,函数调用被认为存在歧义。

在 Visual Studio 2019 中,这会产生以下错误消息:

error C2668: 'foo': ambiguous call to overloaded function
message : could be 'void foo(double)'
message : or       'void foo(int)'
message:尝试转换以匹配实参列表 '(long)'

关键要点

如果编译器在某一步找到多个匹配,就会发生函数调用歧义。这意味着该步骤中的任何匹配都不优于其他匹配。

下面是另一个产生歧义匹配的示例:

C++
void foo(unsigned int)
{
}

void foo(float)
{
}

int main()
{ 
    foo(0);       // int 可以进行数值转换为 unsigned int 或 float
    foo(3.14159); // double 可以进行数值转换为 unsigned int 或 float

    return 0;
}

虽然你可能以为 0 会解析为 foo(unsigned int),但这两个调用都会产生歧义匹配。int 值 0 可以数值转换为 unsigned int 或 float,因此两个重载匹配程度相同,结果是函数调用歧义。

同样适用于 double 转换为 float 或 unsigned int。 两者都是数值转换,因此两个重载匹配程度相同,再次产生歧义。

进阶读者

默认参数也可能导致歧义匹配。 这些情况将在课程中介绍:11.5 -- 默认参数。

解决歧义匹配

由于歧义匹配是编译期错误,必须先消除歧义,程序才能编译。 有几种方法可以解决歧义匹配:

  1. 通常,最好的办法是定义一个新重载函数,使其参数类型与调用时使用的类型完全一致。这样 C++ 就能找到精确匹配。
  2. 也可以显式转换有歧义的实参,使其匹配想调用的函数类型。例如,要让上例中的 foo(0) 匹配 foo(unsigned int),可以这样写:
C++
int x{ 0 };
foo(static_cast<unsigned int>(x)); // 将调用 foo(unsigned int)
  1. 如果实参是字面量,可以使用字面量后缀确保它被解释为正确类型:
C++
foo(0u); // 将调用 foo(unsigned int),因为后缀 'u' 表示 unsigned int,此时完全匹配

常用后缀列表见课程: 5.2 -- Literals。

多参数函数的匹配

如果有多个实参,编译器会依次对每个实参应用匹配规则。最终选择的函数必须满足:每个实参的匹配程度至少不差于其他函数,并且至少有一个实参的匹配优于所有其他函数。换句话说,它至少有一个参数提供更好的匹配,且其他参数都不更差。

如果找到这样的函数,它显然是明确的最佳选择。如果找不到,调用就会被视为歧义(或不匹配)。

例如:

C++
#include <iostream>

void print(char, int)
{
	std::cout << 'a' << '\n';
}

void print(char, double)
{
	std::cout << 'b' << '\n';
}

void print(char, float)
{
	std::cout << 'c' << '\n';
}

int main()
{
	print('x', 'a');

	return 0;
}

在上面的程序中,所有函数都能精确匹配第一个参数。但最上面的函数通过提升匹配第二个参数,而其他函数需要进行转换。因此,print(char, int) 明确是最佳匹配。

最后更新