吃透 C++ 函数重载：从原理到实战的全方位指南
一、什么是函数重载？一句话讲清核心
计算两个 int 的和：
int add(int a, int b)计算两个 double 的和：
double add(double a, double b)计算三个 int 的和：
int add(int a, int b, int c)
add，但参数不同，编译器会根据调用时传入的实参，自动匹配对应的函数，这就是函数重载的核心价值。二、编译器如何 “区分” 同名函数？关键看 “函数签名”
1. 函数签名的构成（必须牢记）
参数个数：比如
add(int a)和add(int a, int b)，个数不同 → 不同签名参数类型：比如
add(int a)和add(double a)，类型不同 → 不同签名参数顺序：比如
add(int a, double b)和add(double a, int b)，顺序不同 → 不同签名
2. 常见误区：这些情况不算重载！
仅返回值不同：
int add(int a)和double add(int a)→ 签名相同，不是重载仅参数名不同：
int add(int a, int b)和int add(int x, int y)→ 签名相同，不是重载
三、函数重载的底层原理：名字修饰（Name Mangling）
add函数：| 原函数名 | 函数签名 | GCC 编译器修饰后名字 |
|---|---|---|
add(int, int) | int+int | _Z3addii |
add(double, double) | double+double | _Z3adddd |
add(int, int, int) | int+int+int | _Z3addiii |
修饰规则解析：
_Z是前缀，3表示原函数名长度（add是 3 个字符），ii/dd表示参数类型（i=int，d=double）。核心作用：通过修饰，同名函数变成了不同的标识符，链接器就能准确找到对应的函数实现。
四、实战：函数重载的使用场景与示例
场景 1：处理不同类型的参数
#include <iostream>#include <string>using namespace std;// 重载1：打印intvoid print(int num) {
cout << "整数：" << num << endl;}// 重载2：打印doublevoid print(double num) {
cout << "小数：" << num << endl;}// 重载3：打印stringvoid print(string str) {
cout << "字符串：" << str << endl;}int main() {
print(10); // 调用print(int) → 输出“整数：10”
print(3.14); // 调用print(double) → 输出“小数：3.14”
print("Hello"); // 调用print(string) → 输出“字符串：Hello”
return 0;}场景 2：处理不同个数的参数
// 求2个int的最大值int max(int a, int b) {
return a > b ? a : b;}// 求3个int的最大值（复用2个参数的版本）int max(int a, int b, int c) {
return max(max(a, b), c); // 嵌套调用max(int, int)}int main() {
cout << max(5, 8) << endl; // 输出8
cout << max(3, 9, 6) << endl; // 输出9
return 0;}场景 3：结合默认参数（注意避坑）
// 重载1：2个参数，无默认值void func(int a, int b) {
cout << "a=" << a << ", b=" << b << endl;}// 重载2：1个参数，有默认值（注意：不要写成func(int a=0)，会和重载1冲突）void func(int a) {
cout << "a=" << a << endl;}int main() {
func(10, 20); // 调用func(int, int) → 正确
func(5); // 调用func(int) → 正确
// func(); // 错误：若func(int a=0)存在，编译器无法判断调用哪个
return 0;}五、避坑指南：函数重载的 3 个常见问题
1. 二义性调用：编译器 “懵了”
void func(int a, double b) {}void func(double a, int b) {}int main() {
// 错误：10是int，20是int，两个函数都能匹配（int可隐式转double）
func(10, 20);
return 0;}func(10.0, 20)或func(10, 20.0)。2. 引用 /const 参数的重载陷阱
void func(int a)和void func(int& a)：算重载（参数类型不同）void func(int& a)和void func(const int& a)：算重载（const 修饰不同）但调用时需注意：非 const 变量会优先匹配非 const 引用，const 变量只能匹配 const 引用。
3. 继承中的重载：子类会 “隐藏” 父类同名函数
class Father {public:
void show(int a) { cout << "Father: " << a << endl; }};class Son : public Father {public:
// 子类同名函数，隐藏父类的show(int)
void show() { cout << "Son" << endl; }};int main() {
Son s;
s.show(); // 正确：调用子类show()
// s.show(10); // 错误：父类show(int)被隐藏，无法直接调用
s.Father::show(10); // 正确：显式指定父类作用域
return 0;}六、总结：函数重载的核心要点
定义条件：同一作用域、同名函数，参数个数 / 类型 / 顺序不同（返回值无关）。
底层原理：编译器通过 “名字修饰”，将同名函数转为唯一标识符。
核心禁忌：避免二义性调用、注意继承中的函数隐藏、不依赖返回值区分重载。
使用价值：减少函数名冗余（不用写 addInt、addDouble）、提升代码可读性与可维护性。
