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)→_Z5printivoid print(double)→_Z5printdvoid print(const char*)→_Z5printPKc
查看符号名的方法（Linux/g++）
- 编译代码并生成目标文件：
g++ -c overload.cpp -o overload.o - 使用
nm命令查看符号表：
输出类似：nm overload.o
这里00000000 T _Z5printi 0000000a T _Z5printd 00000014 T _Z5printPKcT表示符号在代码段（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. 重载函数的优先级规则
当存在多个可能的匹配时，编译器按以下优先级选择：
- 精确匹配（参数类型完全一致）。
- 提升转换（如
char→int，float→double）。 - 标准转换（如
int→long，double→int）。 - 用户自定义转换（如通过构造函数或转换运算符）。
示例：优先级选择
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)被隐藏，无法直接调用。
