C++ 函数重载学习笔记教程
1. 函数重载的概念与意义
函数重载（Function Overloading）是C++中一项重要的多态性特性，它允许在同一作用域内定义多个同名函数，但要求这些函数具有不同的参数列表。
编译器会根据函数调用时提供的参数类型、数量和顺序，自动匹配并调用最适合的函数版本。
函数重载的价值：
- 对功能相似的操作使用统一名称，提高代码可读性和一致性
- 避免为相似功能创建不同名称的函数（如
addInt、addFloat） - 使代码更符合自然语言习惯，例如
print(x)可以打印任何类型的x
2. 函数重载的条件
两个同名函数构成重载，必须满足以下参数列表不同的条件之一：
-
参数数量不同
void display(); // 无参数 void display(int num); // 一个参数 -
参数类型不同
void calculate(int a); // int类型参数 void calculate(double a); // double类型参数 -
参数顺序不同（仅当参数类型不同时有效）
void mix(int a, double b); // int在前，double在后 void mix(double a, int b); // double在前，int在后
注意：以下情况不构成重载：
- 仅返回值类型不同
int add(int a, int b); double add(int a, int b); // 不构成重载，编译错误 - 仅参数名称不同
void func(int a); void func(int b); // 不是重载，是重复定义
3. 函数重载的基本示例
示例1：参数数量不同的重载
#include <iostream>
// 打印提示信息（无参数）
void showMessage() {
std::cout << "请输入一个数字: ";
}
// 打印整数（一个参数）
void showMessage(int num) {
std::cout << "你输入的整数是: " << num << std::endl;
}
// 打印整数和其平方（两个参数）
void showMessage(int num, int square) {
std::cout << "数字: " << num << ", 平方: " << square << std::endl;
}
int main() {
showMessage(); // 调用无参数版本
int x;
std::cin >> x;
showMessage(x); // 调用单参数版本
showMessage(x, x * x); // 调用双参数版本
return 0;
}
输出结果：
请输入一个数字: 5
你输入的整数是: 5
数字: 5, 平方: 25
示例2：参数类型不同的重载
#include <iostream>
#include <string>
// 计算两个整数之和
int sum(int a, int b) {
std::cout << "整数相加: ";
return a + b;
}
// 计算两个双精度浮点数之和
double sum(double a, double b) {
std::cout << "浮点数相加: ";
return a + b;
}
// 拼接两个字符串
std::string sum(std::string a, std::string b) {
std::cout << "字符串拼接: ";
return a + b;
}
int main() {
std::cout << sum(3, 5) << std::endl; // 调用int版本
std::cout << sum(2.5, 4.7) << std::endl; // 调用double版本
std::cout << sum("Hello, ", "Function Overloading") << std::endl; // 调用string版本
return 0;
}
输出结果：
整数相加: 8
浮点数相加: 7.2
字符串拼接: Hello, Function Overloading
示例3：参数顺序不同的重载
#include <iostream>
// 先接收整数，再接收字符串
void logData(int id, std::string message) {
std::cout << "[ID: " << id << "] " << message << std::endl;
}
// 先接收字符串，再接收整数
void logData(std::string message, int priority) {
std::cout << "[优先级: " << priority << "] " << message << std::endl;
}
int main() {
logData(1001, "用户登录成功"); // 匹配第一个版本
logData("系统内存不足", 3); // 匹配第二个版本
return 0;
}
输出结果：
[ID: 1001] 用户登录成功
[优先级: 3] 系统内存不足
4. 函数重载与默认参数
函数重载可以与默认参数结合使用，但需注意避免二义性（编译器无法确定调用哪个函数版本）。
合理使用示例
#include <iostream>
// 基础版本：计算两个数的乘积
int multiply(int a, int b) {
return a * b;
}
// 重载版本：带默认参数，计算三个数的乘积
int multiply(int a, int b, int c = 1) {
return a * b * c;
}
int main() {
std::cout << multiply(2, 3) << std::endl; // 调用第一个版本：2*3=6
std::cout << multiply(2, 3, 4) << std::endl; // 调用第二个版本：2*3*4=24
std::cout << multiply(2, 3, 5) << std::endl; // 调用第二个版本：2*3*5=30
return 0;
}
二义性问题（错误示例）
#include <iostream>
void print(int a) {
std::cout << "整数: " << a << std::endl;
}
void print(int a, int b = 10) { // 默认参数导致潜在的二义性
std::cout << "两个整数: " << a << ", " << b << std::endl;
}
int main() {
// 以下调用会导致编译错误：编译器无法确定调用哪个版本
// print(5); // 错误：call of overloaded 'print(int)' is ambiguous
print(5, 6); // 正确：明确调用第二个版本
return 0;
}
5. 函数重载与引用参数
引用（包括const引用）可以作为函数重载的区分依据，因为const和非const属于不同的类型特征。
#include <iostream>
// 处理非const引用（只能接收非const变量）
void process(int& num) {
std::cout << "处理非const变量: ";
num *= 2; // 可以修改值
}
// 处理const引用（可以接收const变量、字面量和表达式）
void process(const int& num) {
std::cout << "处理const值: ";
// num *= 2; // 错误：不能修改const引用的值
}
int main() {
int x = 10;
const int y = 20;
process(x); // 调用非const版本：x是可修改的变量
std::cout << x << std::endl; // 输出：20
process(y); // 调用const版本：y是const变量
std::cout << y << std::endl; // 输出：20
process(30); // 调用const版本：30是字面量
process(x + y); // 调用const版本：x+y是表达式
return 0;
}
输出结果：
处理非const变量: 20
处理const值: 20
处理const值: 处理const值:
6. 函数重载与函数模板
函数模板可以自动生成多个重载函数（模板实例），与手动定义的重载函数可以共存，且手动定义的重载函数具有更高的优先级。
#include <iostream>
// 函数模板：通用版本
template <typename T>
T max(T a, T b) {
std::cout << "模板版本: ";
return a > b ? a : b;
}
// 手动重载：针对int类型的特殊版本
int max(int a, int b) {
std::cout << "int专用版本: ";
return a > b ? a : b;
}
int main() {
std::cout << max(10, 20) << std::endl; // 调用手动重载的int版本
std::cout << max(10.5, 20.3) << std::endl; // 调用模板生成的double版本
std::cout << max('a', 'z') << std::endl; // 调用模板生成的char版本
return 0;
}
输出结果：
int专用版本: 20
模板版本: 20.3
模板版本: z
7. 函数重载的工作原理
C++编译器通过名字修饰（Name Mangling） 机制区分不同的重载函数：
- 编译时，编译器会根据函数的参数类型、数量等信息，对函数名进行修改
- 修饰后的函数名在底层是唯一的，从而允许链接器正确识别
- 不同编译器的修饰规则不同（如GCC和MSVC采用不同方式）
例如，对于以下重载函数：
void func(int a);
void func(double a);
编译器可能将其修饰为（仅为示例）：
_func_int
_func_double
这种机制使得C++能够支持函数重载，而C语言不支持函数重载的原因正是缺少这种名字修饰机制。
8. 构造函数重载
类的构造函数特别适合使用重载，以支持多种对象初始化方式。
#include <iostream>
#include <string>
class Student {
private:
std::string name;
int age;
float score;
public:
// 默认构造函数：无参数
Student() : name("未知"), age(0), score(0.0f) {}
// 仅初始化姓名
Student(std::string n) : name(n), age(0), score(0.0f) {}
// 初始化姓名和年龄
Student(std::string n, int a) : name(n), age(a), score(0.0f) {}
// 初始化所有成员
Student(std::string n, int a, float s) : name(n), age(a), score(s) {}
void display() {
std::cout << "姓名: " << name
<< ", 年龄: " << age
<< ", 成绩: " << score << std::endl;
}
};
int main() {
Student s1; // 使用默认构造函数
Student s2("张三"); // 使用单参数构造函数
Student s3("李四", 18); // 使用双参数构造函数
Student s4("王五", 19, 95.5f); // 使用三参数构造函数
s1.display();
s2.display();
s3.display();
s4.display();
return 0;
}
输出结果：
姓名: 未知, 年龄: 0, 成绩: 0
姓名: 张三, 年龄: 0, 成绩: 0
姓名: 李四, 年龄: 18, 成绩: 0
姓名: 王五, 年龄: 19, 成绩: 95.5
9. 函数重载的注意事项
-
避免过度重载：过多的重载版本会降低代码可读性，增加维护难度
-
注意作用域：不同作用域中的同名函数不构成重载
#include <iostream> void print(int x) { // 全局函数 std::cout << "全局: " << x << std::endl; } class MyClass { public: void print(int x) { // 类成员函数，与全局函数不在同一作用域 std::cout << "类内: " << x << std::endl; } }; -
C语言兼容性：C语言不支持函数重载，如果需要在C++中调用C函数，需使用
extern "C"声明extern "C" { void c_function(int x); // 告诉编译器按C语言规则处理，不进行名字修饰 } -
避免歧义调用：确保函数调用时能唯一匹配一个重载版本
总结
函数重载是C++中提高代码可读性和灵活性的重要特性，其核心是：
- 同一作用域内的同名函数
- 参数列表必须不同（数量、类型或顺序）
- 编译器通过名字修饰机制区分不同版本
合理使用函数重载可以使代码更加直观和自然，特别是在实现工具函数、构造函数等场景。但需注意避免过度使用和二义性问题，平衡代码的简洁性和可维护性。
0 条评论
目前还没有评论...