函数重载（Function Overloading）

---

1. 函数重载的核心概念

函数重载允许在 同一作用域内定义多个同名函数，但它们的 参数列表（参数类型、顺序或数量）必须不同。编译器在编译时根据 调用时的实参类型和数量 静态选择最匹配的函数版本。

---

2. 源码示例：基础函数重载

示例 1：不同参数类型的重载

#include <iostream>
using namespace std;// 重载函数：参数类型不同
void print(int a) {cout << "整数: " << a << endl;
}void print(double a) {cout << "浮点数: " << a << endl;
}void print(const char* a) {cout << "字符串: " << a << endl;
}int main() {print(10);        // 调用 void print(int)print(3.14);      // 调用 void print(double)print("Hello");   // 调用 void print(const char*)return 0;
}

输出：

整数: 10
浮点数: 3.14
字符串: Hello

关键点：

• 编译器根据实参类型选择函数，例如 10 是 int，直接匹配 print(int)。
• 3.14 默认是 double（不是 float），因此匹配 print(double)。
• 字符串字面量 "Hello" 的类型是 const char*，匹配第三个函数。

---

3. 函数重载的底层实现

C++ 编译器通过 名称修饰（Name Mangling） 为每个重载函数生成唯一的符号名。例如：

• void print(int) → _Z5printi
• void print(double) → _Z5printd
• void print(const char*) → _Z5printPKc

查看符号名的方法（Linux/g++）

1. 编译代码并生成目标文件：

   g++ -c overload.cpp -o overload.o
   

2. 使用 nm 命令查看符号表：

   nm overload.o
   

   输出类似：

   00000000 T _Z5printi
   0000000a T _Z5printd
   00000014 T _Z5printPKc
   

   这里 T 表示符号在代码段（Text Section），后面是修饰后的函数名。

---

4. 示例 2：参数数量和顺序不同

代码示例

#include <iostream>
using namespace std;// 参数数量不同
int add(int a, int b) {return a + b;
}int add(int a, int b, int c) {return a + b + c;
}// 参数顺序不同
void process(int a, double b) {cout << "int, double: " << a << ", " << b << endl;
}void process(double a, int b) {cout << "double, int: " << a << ", " << b << endl;
}int main() {cout << add(1, 2) << endl;        // 调用 add(int, int)cout << add(1, 2, 3) << endl;     // 调用 add(int, int, int)process(10, 3.14);                // 调用 process(int, double)process(3.14, 10);               // 调用 process(double, int)return 0;
}

输出：

3
6
int, double: 10, 3.14
double, int: 3.14, 10

关键点：

• 参数数量不同（如 add 的两个版本）。
• 参数顺序不同（如 process 的两个版本），编译器根据实参顺序匹配。

---

5. 函数重载的歧义问题

示例 1：默认参数导致歧义

void func(int a, int b = 0) {cout << "func(int, int)" << endl;
}void func(int a) {cout << "func(int)" << endl;
}int main() {func(10);  // ❌ 编译错误：无法确定调用哪个函数return 0;
}

问题分析：

• 调用 func(10) 可以匹配 func(int)，也可以匹配 func(int, int)（第二个参数使用默认值 0）。
• 编译器无法确定选择哪个函数，因此报错。

---

示例 2：类型转换歧义

void print(long a) {cout << "long: " << a << endl;
}void print(double a) {cout << "double: " << a << endl;
}int main() {print(10);  // ❌ 编译错误：无法确定调用哪个函数return 0;
}

问题分析：

• 10 是 int 类型，可以隐式转换为 long 或 double。
• 编译器无法确定哪种转换更优，因此报错。

---

6. 重载函数的优先级规则

当存在多个可能的匹配时，编译器按以下优先级选择：

1. 精确匹配（参数类型完全一致）。
2. 提升转换（如 char → int，float → double）。
3. 标准转换（如 int → long，double → int）。
4. 用户自定义转换（如通过构造函数或转换运算符）。

示例：优先级选择

void print(int a) {cout << "int: " << a << endl;
}void print(double a) {cout << "double: " << a << endl;
}int main() {short s = 10;print(s);  // 调用 print(int)（short 提升为 int）print(10L); // 调用 print(double)（long 转换为 double）return 0;
}

输出：

int: 10
double: 10

---

7. 类成员函数的重载

函数重载不仅适用于全局函数，也适用于类的成员函数。

示例：类中的重载

#include <iostream>
using namespace std;class Calculator {
public:int add(int a, int b) {return a + b;}double add(double a, double b) {return a + b;}string add(const string& a, const string& b) {return a + b;}
};int main() {Calculator calc;cout << calc.add(1, 2) << endl;           // 调用 int add(int, int)cout << calc.add(1.5, 2.5) << endl;       // 调用 double add(double, double)cout << calc.add("Hello, ", "World!") << endl; // 调用 string add(const string&, const string&)return 0;
}

输出：

3
4
Hello, World!

---

8. 函数重载 vs. 模板

函数重载需要为每个类型手动编写函数，而模板可以自动生成代码。

函数重载实现

int max(int a, int b) { return (a > b) ? a : b; }
double max(double a, double b) { return (a > b) ? a : b; }

模板实现

template <typename T>
T max(T a, T b) {return (a > b) ? a : b;
}

区别：

• 重载需要显式定义每个类型。
• 模板通过泛型编程自动适配类型，但可能无法处理某些特殊逻辑。

---

9. 总结

• 函数重载是静态多态的核心机制，通过编译时绑定实现高效代码。
• 核心规则：同名函数参数列表不同。
• 编译器通过 名称修饰（Name Mangling） 生成唯一符号。
• 注意避免歧义（如默认参数、隐式转换冲突）。

---

多选题

题目 1：函数重载的核心规则

以下哪些情况可以构成合法的函数重载？

A. 两个函数的参数类型不同：void func(int); 和 void func(double);
B. 两个函数的参数数量不同：void func(int); 和 void func(int, int);
C. 两个函数的返回值类型不同：int func(int); 和 double func(int);
D. 两个函数的参数顺序不同：void func(int, double); 和 void func(double, int);

---

题目 2：类型转换与重载歧义

以下代码是否会编译失败？为什么？

void print(long a) { /* ... */ }
void print(double a) { /* ... */ }int main() {print(10);  // 调用哪个函数？return 0;
}

A. 编译成功，调用 print(long)，因为 int 到 long 是标准转换
B. 编译成功，调用 print(double)，因为 int 到 double 是提升转换
C. 编译失败，因为 int 可以隐式转换为 long 或 double，导致歧义
D. 编译成功，因为 int 到 double 的转换优先级更高

---

题目 3：默认参数与重载冲突

以下代码是否会编译失败？

void process(int a, int b = 0) { /* ... */ }
void process(int a) { /* ... */ }int main() {process(10);  // 调用哪个函数？return 0;
}

A. 编译成功，调用 process(int)
B. 编译成功，调用 process(int, int)
C. 编译失败，因为默认参数导致歧义
D. 编译成功，因为默认参数的优先级更低

---

题目 4：模板函数与重载的优先级

以下代码的输出是什么？

#include <iostream>
using namespace std;template <typename T>
void print(T a) { cout << "模板函数: " << a << endl; }void print(int a) { cout << "重载函数: " << a << endl; }int main() {print(10);     // 调用哪个函数？print(10.5);   // 调用哪个函数？return 0;
}

A. 两次都调用模板函数
B. 两次都调用重载函数
C. print(10) 调用重载函数，print(10.5) 调用模板函数
D. print(10) 调用模板函数，print(10.5) 调用重载函数

---

题目 5：作用域与函数重载

以下代码的输出是什么？

#include <iostream>
using namespace std;class Base {
public:void func(int a) { cout << "Base::func(int)" << endl; }
};class Derived : public Base {
public:void func(double a) { cout << "Derived::func(double)" << endl; }
};int main() {Derived obj;obj.func(10);     // 调用哪个函数？obj.func(10.5);   // 调用哪个函数？return 0;
}

A. 两次都调用 Derived::func(double)
B. func(10) 调用 Base::func(int)，func(10.5) 调用 Derived::func(double)
C. 编译成功，Derived 隐藏了 Base::func(int)
D. 两次都调用 Base::func(int)

---

---

答案与解析

题目 1：函数重载的核心规则

答案：A、B、D
解析：

• A 正确：参数类型不同是合法的重载。
• B 正确：参数数量不同是合法的重载。
• C 错误：仅返回值不同不足以构成重载。
• D 正确：参数顺序不同是合法的重载。

---

题目 2：类型转换与重载歧义

答案：C
解析：

• int 可以隐式转换为 long（标准转换）或 double（提升转换），但两者优先级相同，编译器无法确定哪个更优，导致歧义，编译失败。
• 提升转换（如 int → double）和标准转换（如 int → long）的优先级在 C++ 中可能因编译器实现不同，但此处两者没有明确的优先级高低。

---

题目 3：默认参数与重载冲突

答案：C
解析：

• process(10) 可以匹配 process(int) 或 process(int, int)（第二个参数使用默认值），编译器无法确定调用哪个函数，导致编译失败。

---

题目 4：模板函数与重载的优先级

答案：C
解析：

• 当模板函数和非模板重载函数同时匹配时，非模板函数优先级更高。
• print(10) 精确匹配 void print(int)，调用重载函数。
• print(10.5) 没有重载的 double 版本，调用模板函数。

---

题目 5：作用域与函数重载

答案：A、C
解析：

• C 正确：派生类中定义的 func(double) 会隐藏基类的 func(int)（即使参数不同）。
• A 正确：所有调用都会优先查找派生类的作用域，因此 obj.func(10) 会将 int 隐式转换为 double，调用 Derived::func(double)。
• B 错误：基类的 func(int) 被隐藏，无法直接调用。

---