【C++ 函数重载】—— 现代编译技术下的多态表达与性能优化

换一颗红豆

发布于 2025-03-05 08:52:04

14200

代码可运行

文章被收录于专栏：C++进阶之路C++进阶之路

运行总次数：0

代码可运行

课前导入

看下面一段C语言代码：

void Swap(int *x, int *y)
{
	int temp = *x;
	*x = *y;
	*y = temp;
}

如上代码，我们通过指针传参实现了一个交换两个int变量的Swap函数。那么问题来了，如果我们需要交换两个float变量呢？我们需要交换两个char 变量呢？这个函数显然已经不适用了，我们需要实现新的函数来满足交换的需求！

float版本的函数：

void Swap_float(float *x, float *y)
{
	float temp = *x;
	*x = *y;
	*y = temp;
}

char版本的函数：

void Swap_char(char *x, char *y)
{
	char temp = *x;
	*x = *y;
	*y = temp;
}

由于C语言不支持定义多个同名函数，所以我们在函数命名也要作出修改。如此看来，明明是逻辑完全相同的一段带代码，却因为参数不同需要我们实现多个版本的函数，这会导致大量代码冗余，增加维护成本。

C++中支持函数重载，对此给出了一定的解决方案。

函数重载

在 C++ 中，函数重载（Function Overloading）是一种允许在同一作用域内定义多个同名函数，但这些函数的参数列表不同的特性 。通过函数重载，程序员可以使用相同的函数名来执行相似但又不完全相同的任务，提高了代码的可读性和可维护性。

函数重载的条件

同名函数：

函数名称必须相同，才能构成函数重载

参数列表不同：

参数类型不同（如 int 与 double）。
参数数量不同（如单参数与多参数）。
参数顺序不同（如 int, double 与 double, int）。

返回类型无关：

仅返回类型不同不构成重载。

例如：

参数个数不同：

// 函数接受一个整数参数
void print(int num) {
    std::cout << "Printing single integer: " << num << std::endl;
}

// 函数接受两个整数参数
void print(int num1, int num2) {
    std::cout << "Printing two integers: " << num1 << " and " << num2 << std::endl;
}

int main() {
    print(10);        // 调用 print(int num)
    print(20, 30);    // 调用 print(int num1, int num2)
    return 0;
}

在上述代码中，print 函数有两个重载版本，一个接受一个整数参数，另一个接受两个整数参数。编译器根据调用时提供的实参个数来决定调用哪个版本的函数。

参数类型不同：

// 函数接受一个整数参数
void display(int num) {
    std::cout << "Displaying integer: " << num << std::endl;
}

// 函数接受一个字符串参数
void display(const std::string& str) {
    std::cout << "Displaying string: " << str << std::endl;
}

int main() {
    display(100);           // 调用 display(int num)
    display("Hello, World"); // 调用 display(const std::string& str)
    return 0;
}

这里，display 函数有两个重载版本，一个接受整数类型的参数，另一个接受字符串类型的参数。编译器根据实参的类型来选择合适的函数进行调用。

参数类型顺序不同：

// 函数接受一个整数和一个双精度浮点数
void process(int i, double d) {
    std::cout << "Processing int then double: " << i << ", " << d << std::endl;
}

// 函数接受一个双精度浮点数和一个整数
void process(double d, int i) {
    std::cout << "Processing double then int: " << d << ", " << i << std::endl;
}

int main() {
    process(1, 2.5);    // 调用 process(int i, double d)
    process(3.5, 2);    // 调用 process(double d, int i)
    return 0;
}

在这个例子中，process 函数的两个重载版本参数类型相同，但顺序不同，编译器会根据实参的类型顺序来决定调用哪个函数。

如上所述，仅返回类型不同的函数不能构成重载。

以下代码会导致编译错误：

// 尝试通过返回类型区分函数，但这是不允许的
int func(int num) {
    return num;
}

// 编译错误：与上面的函数仅返回类型不同，不能构成重载
double func(int num) {
    return static_cast<double>(num);
}

int main() {
    return 0;
}

编译出错：

注意：

static_cast 运算符：

static_cast 是 C++ 中的一种类型转换运算符，用于在编译时进行类型转换。它可以用于多种类型转换场景，例如：

基本数据类型之间的转换，像整数和浮点数之间的转换。
具有继承关系的类指针或引用之间的转换。
与 C 风格的强制类型转换（如 (double)num）相比，static_cast更安全，因为它会在编译时进行一些类型检查，并且代码的可读性更高，能更清晰地表达程序员的意图。

编译器的匹配原则

当调用一个重载函数时，编译器会按照以下步骤来确定调用哪个重载版本：

确定候选函数

范围界定：

编译器会在当前作用域内查找所有与调用函数同名的函数，这些函数构成候选函数集合。作用域可以是全局作用域、类作用域等。
例如在一个程序中，有多个同名的 print 函数，无论它们是全局函数还是类的成员函数，只要在当前调用点可见，都会被纳入候选函数范围。

示例代码：

void print(int num);
void print(double num);
class MyClass {
public:
    void print(const char* str);
};

int main() {
    // 这里所有名为 print 的函数都是候选函数
    return 0;
}

筛选可行函数

参数数量匹配：

从候选函数中筛选出参数个数与调用时提供的实参个数相同，或者参数个数多但多出来的参数有默认值的函数。例如，有一个函数 func(int a)和 func(int a, int b = 0)，当调用 func(10) 时，这两个函数都满足参数数量的要求，会被视为可行函数。

类型兼容性：

实参类型必须能够隐式转换为候选函数的参数类型。例如，char 类型的实参可以隐式转换为 int 类型，所以当有函数 func(int a)时，传递 char 类型的实参也能使该函数成为可行函数。

示例代码：

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

void func(int a, double b = 0.0) {
    std::cout << "func(int a, double b)" << std::endl;
}

int main() {
    func(10); // 可行函数为 func(int a) 和 func(int a, double b)
    return 0;
}

选择最佳匹配函数

如果有多个可行函数，编译器会根据实参到形参的类型转换规则，选择一个最佳匹配的函数。转换规则从优到劣依次为：

精确匹配 > 类型提升> 标准转换> 用户自定义转换。

精确匹配

匹配规则：实参类型与形参类型完全相同，或者实参是形参的 const 或 volatile 版本。

例如，当调用函数传递 int 类型的实参时，优先匹配参数类型为 int 的函数；如果有参数类型为 const int 的函数，也属于精确匹配。

示例代码：

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

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

int main() {
    int num = 10;
    func(num); // 精确匹配 func(int a) 或 func(const int a)
    return 0;
}

类型提升

提升规则：例如 char、short 等类型会提升为 int，float 会提升为 double等。这种提升是自动进行的，当没有精确匹配的函数时，编译器会优先考虑经过类型提升后能匹配的函数。

示例代码：

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

void func(double b) {
    std::cout << "func(double b)" << std::endl;
}

int main() {
    char ch = 'A';
    func(ch); // 发生类型提升，调用 func(int a)
    return 0;
}

标准转换

转换规则：如 int 转换为 double，int* 转换为 void*等。标准转换的优先级低于类型提升，只有在没有精确匹配和类型提升匹配的情况下才会考虑。

示例代码：

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

void func(double b) {
    std::cout << "func(double b)" << std::endl;
}

int main() {
    func(10.5); // 调用 func(double b)，发生标准转换
    return 0;
}

用户自定义转换

转换规则：通过类的构造函数或类型转换运算符实现的转换。
例如，一个类有一个接受 int类型参数的构造函数，那么在调用接受该类对象为参数的函数时，可以传递 int 类型的实参，编译器会使用该构造函数进行转换。

示例代码：

class MyClass {
public:
    MyClass(int val) : value(val) {}
private:
    int value;
};

void func(const MyClass& obj) {
    std::cout << "func(const MyClass& obj)" << std::endl;
}

int main() {
    func(10); // 调用 func(const MyClass& obj)，通过 MyClass 的构造函数进行用户自定义转换
    return 0;
}

如果找不到最佳匹配的函数，或者有多个函数匹配程度相同（二义性），编译器会报错。

函数重载的注意事项

注意二义性

在设计重载函数时，要避免出现二义性的情况，即编译器无法确定调用哪个重载版本的函数。这种情况通常发生在多个可行函数的匹配程度相同，无法根据类型转换规则选出最佳匹配函数时。

示例代码：

void func(int a, double b) {
    std::cout << "func(int a, double b)" << std::endl;
}

void func(double a, int b) {
    std::cout << "func(double a, int b)" << std::endl;
}

int main() {
    func(10, 20); // 二义性错误，编译器无法确定调用哪个函数
    return 0;
}

编译出错：

在设计函数参数时，要仔细考虑参数类型和顺序，避免出现可能导致二义性的情况。如果无法避免，可以通过修改函数名或调整参数类型来解决。

结合默认参数使用时要谨慎

当函数重载与默认参数结合使用时，可能会导致调用的不确定性。例如，一个函数有默认参数，另一个重载函数的参数个数与该函数去掉默认参数后的个数相同，这会使调用时难以明确调用的是哪个函数。

示例代码：

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

void func(int a, double b = 0.0) {
    std::cout << "func(int a, double b)" << std::endl;
}

int main() {
    func(10); // 对重载函数的调用不明确
    return 0;
}

编译出错:

仅返回类型不同不能构成重载

函数的返回类型不能作为函数重载的依据，也就是说，仅返回类型不同的函数不能构成重载。编译器在调用函数时，仅根据函数名和实参来确定调用哪个函数，无法仅通过返回类型来区分不同的函数。

示例代码：

int func(int num) {
    return num;
}

// 编译错误：与上面的函数仅返回类型不同，不能构成重载
double func(int num) {
    return static_cast<double>(num);
}

int main() {
    return 0;
}

编译出错

如果需要不同返回类型的函数，要通过改变参数列表来实现函数重载，或者使用不同的函数名。

作用域和可见性

函数重载的匹配是在当前作用域内进行的。如果在不同的作用域中有同名的函数，可能会导致意外的调用结果。例如，在类的成员函数中调用一个全局函数，如果类中也有同名的成员函数，可能会优先调用成员函数而不是全局函数。

要明确函数的作用域和可见性，必要时可以使用作用域解析运算符 :: 来指定调用的函数。::func() 表示调用全局作用域中的 func 函数。

例如：

// 全局作用域中的 func 函数
void func() {
    std::cout << "Global function func() is called." << std::endl;
}

class MyClass {
public:
    // 类作用域中的 func 函数
    void func() {
        std::cout << "Member function func() of MyClass is called." << std::endl;
    }

    // 类的成员函数，用于测试函数调用
    void testCall() {
        // 直接调用 func，会优先调用类的成员函数
        func();
        // 使用作用域解析运算符调用全局函数
        ::func();
    }
};

int main() {
    MyClass obj;
    // 调用类的成员函数 testCall
    obj.testCall();
    // 在全局作用域中直接调用全局函数
    func();
    return 0;
}

输出：

Member function func() of MyClass is called.
Global function func() is called.
Global function func() is called.

通过这个示例可以清楚地看到，不同作用域中同名函数的调用可能会产生意外结果，而使用作用域解析运算符 :: 可以明确指定要调用的函数所在的作用域。

函数重载的不足

有了C++的函数重载，我们就可以通过重载来实现多个版本的Swap函数从而满足对多种不同类型的变量交换！

void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
}
void Swap(double& left, double& right)
{
	double temp = left;
	left = right;
	right = temp;
}
void Swap(char& left, char& right)
{
	char temp = left;
	left = right;
	right = temp;
}

使用函数重载虽然可以实现，在编程中提供了很多便利，但也存在一些不足之处：

代码可读性降低

调用时难以区分：当存在多个重载函数时，调用者可能难以立即确定应该使用哪个重载版本。特别是当重载函数的参数类型或数量差异不明显时，代码的阅读者需要花费更多时间去理解每个重载版本的具体用途。

// 重载函数
void print(int num) {
    std::cout << "Printing integer: " << num << std::endl;
}

void print(double num) {
    std::cout << "Printing double: " << num << std::endl;
}

int main() {
    // 调用时需要仔细区分参数类型
    print(10);
    print(3.14);
    return 0;
}

在上述代码中，如果有更多不同类型的print重载函数，调用时就需要更仔细地考虑参数类型，这会增加阅读和理解代码的难度。

可维护性变差

修改和扩展困难：当需要对重载函数进行修改或扩展时，可能会影响到其他相关的重载版本。例如，为一个重载函数添加新的功能，可能需要在所有重载版本中进行相应的修改，否则会导致功能不一致。

// 重载函数
void calculate(int a, int b) {
    std::cout << "Integer result: " << a + b << std::endl;
}

void calculate(double a, double b) {
    std::cout << "Double result: " << a + b << std::endl;
}

// 如果要添加日志功能，需要在两个重载函数中都添加
void calculate(int a, int b) {
    std::cout << "Calculating integers..." << std::endl;
    std::cout << "Integer result: " << a + b << std::endl;
}

void calculate(double a, double b) {
    std::cout << "Calculating doubles..." << std::endl;
    std::cout << "Double result: " << a + b << std::endl;
}

上述代码中，如果要为calculate函数添加日志功能，就需要在两个重载版本中都进行修改，增加了维护的工作量。

编译复杂度增加

编译器匹配负担加重：编译器在处理重载函数调用时，需要根据调用时提供的参数类型和数量，从多个重载版本中选择最合适的函数。当重载函数的数量较多或参数类型复杂时，编译器的匹配过程会变得更加复杂，从而增加编译时间。

// 多个重载函数
void func(int a) { std::cout << "func(int)" << std::endl; }
void func(double a) { std::cout << "func(double)" << std::endl; }
void func(int a, int b) { std::cout << "func(int, int)" << std::endl; }
void func(double a, double b) { std::cout << "func(double, double)" << std::endl; }

int main() {
    func(10);
    func(3.14);
    func(1, 2);
    func(3.14, 2.71);
    return 0;
}

上述代码中，编译器需要在多个重载版本中进行匹配，随着重载函数数量的增加，编译复杂度会显著提高。

函数重载的底层原理

编译器处理的大致流程

函数重载主要是由编译器来分析和实现的

首先编译器进行词法分析（Lexical Analysis）

输入：源码字符流（如 void func(int);）。

输出：标记（Token）序列（如 void, func, (, int, ), ;）。

作用：将代码分解为基本语法单元，但此时不处理函数重载。

完成词法分析后，编译器会进行语法分析（Syntax Analysis）

输入：标记序列。

输出：抽象语法树（Abstract Syntax Tree, AST）。

示例：AST 中 func(int) 和 func(double) 会被解析为两个独立的函数声明节点。

作用：确定代码结构，但尚未解决重载冲突。

以上步骤完成后，编译器进行语义分析（Semantic Analysis）

关键阶段：重载解析（Overload Resolution）在此阶段完成。

步骤：

符号表（Symbol Table）管理：

编译器维护一个符号表，记录每个作用域内的函数名及其参数类型。
同名函数根据参数列表被存储为不同的符号条目。

重载候选函数收集：

当遇到函数调用（如 func(10)）时，编译器收集所有同名且可见的函数声明作为候选函数。

可行函数筛选：

排除参数数量不匹配或类型无法隐式转换的函数。

最佳匹配选择：

根据 C++ 标准规则（如精确匹配 > 类型提升 > 隐式转换 > 可变参数）选择最优函数。

若存在多个“最佳匹配”，编译器报错（歧义调用）。

示例：

void func(int);    // Candidate 1
void func(double); // Candidate 2
func(10);          // 选择 Candidate 1（精确匹配 int）

紧接着会进行，中间代码生成（Intermediate Code Generation）

输入：AST 和符号表。

输出：与平台无关的中间表示（如 LLVM IR、GIMPLE）。

关键操作：

根据重载决议结果，为每个函数调用生成对应的中间代码。
函数名已被修饰（如 _Z4funci 和 _Z4funcd），确保唯一性。

名称修饰（Name Mangling）

在 C++ 中，由于存在函数重载，同名函数会有不同的参数列表。为了在编译后的目标文件和链接过程中区分这些同名但参数不同的函数，编译器会对函数名进行名称修饰。名称修饰是将函数名和其参数类型等信息编码成一个唯一的字符串，这个字符串会作为函数在内部的实际标识符。不同的编译器有不同的名称修饰规则，例如 GCC 和 Clang 使用的是一种基于参数类型和函数名长度等信息的编码方式，而 Microsoft Visual C++ 则有自己独特的编码规则。

规则细节（以 Itanium ABI 为例）：

修饰后的名称格式：_Z[函数名长度][函数名][参数类型编码]。

参数类型编码：

i → int

d → double

P → 指针（如 Pi 表示 int*）

R → 引用（如 Ri 表示 int&）

示例：

void func(int, double*) → _Z4funcPiPd

int ClassA::method(char&) → _ZN6ClassA6methodERc

输出结果中会包含修饰后的函数名，例如可能会看到类似 _Z4funci 和 _Z4funcd 的符号，其中 _Z 是 GCC 名称修饰的前缀，4 表示函数名 func 的长度，i 表示参数类型为 int，d 表示参数类型为 double。

作用：

解决同名函数在符号表中的唯一性问题。编码命名空间、类名、模板参数等信息。

接下来进行，对目标代码生成与优化

输入：中间代码。

输出：目标文件（.o 或 .obj）。

关键操作：

将修饰后的函数名写入目标文件的符号表。生成与平台相关的机器指令（如 x86 的 call _Z4funci）。执行内联展开、死代码消除等优化。

下一步由链接器进行链接（Linking）

输入：多个目标文件。

输出：可执行文件或库。

关键操作：

链接器通过修饰后的名称解析外部符号引用。

若找不到匹配的符号（如名称修饰不一致），引发链接错误。

如下图所示：

底层数据结构和算法

在 C++ 函数重载的底层实现中，涉及到多种数据结构和算法，它们共同支撑着名称修饰、函数匹配、编译和链接等过程。下面详细介绍其中用到的底层数据结构与算法。

符号表（Symbol Table）

作用：符号表是编译器中非常重要的数据结构，用于记录程序中各种符号（如变量、函数等）的信息。在函数重载的场景下，符号表会存储每个重载函数的名称、参数类型、返回值类型、函数地址等信息。编译器在编译过程中通过符号表来查找和管理函数，在函数匹配时，会从符号表中获取候选函数的信息进行匹配。
实现方式：符号表通常可以使用哈希表（HashTable）或平衡二叉搜索树（如红黑树）来实现。哈希表的查找、插入和删除操作的平均时间复杂度为O(1)，适合快速查找符号信息；平衡二叉搜索树的查找、插入和删除操作的时间复杂度为 O(logn)，可以保证符号表的有序性，便于进行范围查找等操作。

示例代码（简单模拟符号表）：

#include <iostream>
#include <unordered_map>
#include <vector>
#include <string>

// 表示函数信息的结构体
struct FunctionInfo {
    std::string returnType;
    std::vector<std::string> parameterTypes;
};

// 符号表，使用哈希表实现
std::unordered_map<std::string, FunctionInfo> symbolTable;

// 插入函数信息到符号表
void insertFunction(const std::string& name, const std::string& returnType, const std::vector<std::string>& parameterTypes) {
    FunctionInfo info;
    info.returnType = returnType;
    info.parameterTypes = parameterTypes;
    symbolTable[name] = info;
}

// 从符号表中查找函数信息
FunctionInfo lookupFunction(const std::string& name) {
    auto it = symbolTable.find(name);
    if (it != symbolTable.end()) {
        return it->second;
    }
    return {"", {}};
}

int main() {
    // 插入函数信息
    insertFunction("func", "void", {"int"});
    insertFunction("func", "void", {"double"});

    // 查找函数信息
    FunctionInfo info = lookupFunction("func");
    std::cout << "Return type: " << info.returnType << std::endl;
    for (const auto& param : info.parameterTypes) {
        std::cout << "Parameter type: " << param << std::endl;
    }

    return 0;
}

抽象语法树（Abstract Syntax Tree, AST）

作用：抽象语法树是源代码语法结构的一种抽象表示，它以树状结构的形式展现了代码的语法层次。在编译过程中，编译器首先会对源代码进行词法分析和语法分析，生成抽象语法树。对于函数重载的处理，编译器会在抽象语法树上进行函数定义和调用的分析，确定函数的参数和返回值类型等信息，为后续的名称修饰和函数匹配提供基础。
实现方式：抽象语法树通常由节点（Node）和边（Edge）组成，每个节点代表一个语法结构，边表示节点之间的关系。可以使用面向对象的方式来实现抽象语法树，每个节点类继承自一个基类，不同类型的节点具有不同的属性和方法。

名称修饰算法

作用：名称修饰算法用于将函数名和参数类型等信息编码成一个唯一的字符串，以区分不同的重载函数。不同的编译器有不同的名称修饰规则，但一般都会考虑函数名的长度、参数类型的编码等因素。

示例（简单模拟 GCC 名称修饰规则）：

#include <iostream>
#include <string>
#include <vector>

// 简单的类型编码函数
std::string encodeType(const std::string& type) {
    if (type == "int") return "i";
    if (type == "double") return "d";
    return "";
}

// 名称修饰函数
std::string mangleName(const std::string& name, const std::vector<std::string>& parameterTypes) {
    std::string mangledName = "_Z" + std::to_string(name.length()) + name;
    for (const auto& type : parameterTypes) {
        mangledName += encodeType(type);
    }
    return mangledName;
}

int main() {
    std::string functionName = "func";
    std::vector<std::string> paramTypes1 = {"int"};
    std::vector<std::string> paramTypes2 = {"double"};

    std::string mangledName1 = mangleName(functionName, paramTypes1);
    std::string mangledName2 = mangleName(functionName, paramTypes2);

    std::cout << "Mangled name 1: " << mangledName1 << std::endl;
    std::cout << "Mangled name 2: " << mangledName2 << std::endl;

    return 0;
}

函数匹配算法

作用：函数匹配算法用于在调用重载函数时，从多个候选函数中选择一个最合适的函数。该算法会根据实参的类型、数量和顺序，按照精确匹配、类型提升匹配、标准类型转换匹配、用户自定义类型转换匹配的优先级进行筛选。

实现步骤：

确定候选函数：遍历符号表，找出所有与调用函数同名的函数。
选择可行函数：检查候选函数的参数数量和类型是否与实参兼容，实参可以通过隐式类型转换与可行函数的参数类型匹配。
寻找最佳匹配函数：在可行函数中，根据匹配优先级选择最佳匹配函数。如果没有找到最佳匹配函数，或者存在多个同等匹配的函数，编译器会报错。

链接算法

作用：链接算法用于将多个目标文件和库文件链接成一个可执行文件。在链接过程中，链接器会根据名称修饰后的函数名，将函数调用和函数定义进行关联，解决符号引用问题。

实现步骤：

符号收集：链接器会收集所有目标文件和库文件中的符号信息，包括函数名、变量名等。
符号解析：链接器会解析每个符号引用，查找对应的符号定义。如果找不到符号定义，链接器会报错。
地址重定位：链接器会为每个符号分配最终的内存地址，并对代码中的符号引用进行重定位，确保程序能够正确地调用相应的函数和访问变量。

编译器差异与 ABI 兼容性

GCC/Clang（Itanium ABI）

名称修饰规则：公开且标准化，支持跨编译器链接（如 Clang 与 GCC 混合编译）。

示例：

namespace N { void func(int); }
// 修饰后名称：_ZN1N4funcEi

MSVC（Microsoft ABI）

名称修饰规则：更复杂且不公开，包含调用约定（如 __cdecl、__stdcall）信息。

示例：

void __cdecl func(int);
// 修饰后名称：?func@@YAXH@Z

ABI 兼容性问题

不同编译器生成的修饰名称不兼容，导致无法直接链接。
解决方案：使用 extern "C" 禁止名称修饰（但牺牲重载功能）。

本文总结

概念

函数重载允许在同一作用域内定义多个同名但参数列表不同的函数。编译器会根据调用时提供的实参信息，自动选择合适的函数进行调用。这使得程序员可以使用相同的函数名来处理不同类型或不同数量的参数，让代码更符合人类的思维习惯。

规则

参数列表必须不同：可以通过参数的个数、类型或顺序来体现差异。例如 void func(int a) 和 void func(int a,int b)（参数个数不同）；void func(int a) 和 void func(double a)（参数类型不同）；void func(int a, double b) 和 void func(double a, int b)（参数顺序不同）均构成函数重载。
返回值类型不能作为重载依据：仅返回值类型不同的函数不能构成重载，因为在调用函数时，编译器无法根据返回值类型来确定调用哪个函数。

底层原理

名称修饰（NameMangling）：编译器会对重载函数的名称进行特殊处理，将函数名和参数列表信息组合成一个唯一的内部名称，以此避免命名冲突。不同编译器有不同的名称修饰规则。
函数匹配：调用重载函数时，编译器会先确定候选函数，再从中筛选出可行函数，最后根据精确匹配、类型提升匹配、标准类型转换匹配、用户自定义类型转换匹配的优先级选择最佳匹配函数。若没有最佳匹配或存在多个同等匹配，编译器会报错。
编译和链接：编译阶段，编译器根据名称修饰和函数匹配规则处理函数调用并生成机器代码，同时在目标文件记录函数符号信息；链接阶段，链接器根据修饰后的函数名关联函数调用和定义，若找不到函数定义则报错。

优缺点

优点