C++98函数接口：重载与默认参数
完整的仓库地址在 Tutorial_AwesomeModernCPP 中，您也可以光顾一下，喜欢的话给一个 Star 激励一下作者
在上一篇中，我们学习了命名空间、引用和作用域解析——这些特性让代码的组织方式更加清晰。现在我们来看 C++ 在函数层面提供的两个重要改进：函数重载和默认参数。
这两个特性解决的是同一个问题——如何设计更好的函数接口。在 C 里，如果你想让同一个"概念"支持不同的参数类型，你得给每个版本起不同的名字：print_int()、print_float()、print_string()……光是起名字就够让人崩溃的。函数重载让你用同一个名字搞定这件事。默认参数则从另一个角度切入：当一个函数的大部分参数在绝大多数调用场景下都取固定值时，为什么每次调用都要把那些"废话参数"写全呢？
1. 函数重载 (Function Overloading)
1.1 基本概念
函数重载允许多个函数使用相同的名称，只要它们的参数列表不同。"参数列表不同"指的是参数的类型、数量不同——注意，返回类型不同不算，编译器不会仅凭返回类型来区分重载。
来看最基本的例子：
void print(int value) {
printf("Integer: %d\n", value);
}
void print(float value) {
printf("Float: %f\n", value);
}
void print(const char* str) {
printf("String: %s\n", str);
}调用的时候，编译器会根据实参的类型自动选择对应的版本：
print(42); // 调用 print(int)
print(3.14f); // 调用 print(float)
print("Hello"); // 调用 print(const char*)在 C 里，要实现同样的效果，你必须写三个不同名字的函数——print_int()、print_float()、print_string()，然后每次调用的时候还得自己判断该用哪个。对比之下，函数重载在 API 设计层面的优势是显而易见的。
参数数量不同也可以构成重载：
void init_uart(int baudrate) {
// 使用默认配置：8 数据位、1 停止位、无校验
}
void init_uart(int baudrate, int databits, int stopbits) {
// 使用自定义配置
}这种模式在嵌入式开发中非常常见——外设初始化函数往往需要提供"推荐配置"和"完全自定义"两种入口，重载让这件事变得很自然。
1.2 重载解析规则
表面上看，调用一个重载函数只是"写个名字、传个参数"这么简单的事。但实际上，编译器在背后执行了一套非常严格的决策流程——这套流程被称为重载解析 (Overload Resolution)。
每当你调用一个存在多个重载版本的函数时，编译器都会先收集所有名字匹配、参数数量一致的候选函数，然后逐一评估，试图回答一个问题：**哪一个是"最合适"的？**需要强调的是，编译器并不会理解你的业务语义，它只会机械地按照语言规则打分，最终选出匹配度最高的版本。
在涉及模板和可变参数之前，编译器的判断标准可以理解为一条由强到弱的"匹配优先级链"。首先是精确匹配——实参与形参类型完全一致；如果不存在精确匹配，才会考虑类型提升，比如 char 提升为 int；再往后是标准类型转换，例如 int 转换为 double；最后才轮到用户自定义的类型转换。这个顺序非常关键，因为只要某一层级已经能找到可行的匹配，后面的规则就完全不会被考虑，哪怕它们在你看来更"合理"。
我们用一个最常见的例子来演示。假设我们同时定义了 process(int) 和 process(double) 两个函数：
void process(int x) { }
void process(double x) { }调用 process(5) 时，编译器几乎不需要思考：字面量 5 本身就是 int，这属于精确匹配，而 process(double) 需要一次从 int 到 double 的转换。在重载解析的规则下，精确匹配对任何形式的转换都有压倒性优势，因此最终调用的一定是 process(int)。同样地，调用 process(5.0) 时，5.0 是 double，这一次精确匹配发生在 process(double) 上，另一个版本反而需要进行带有精度风险的转换，自然会被淘汰。
稍微容易让人困惑的是 process(5.0f) 这种情况。5.0f 的类型是 float，而我们并没有 process(float) 的重载。此时编译器会比较两条可能的路径：float 转换为 double，以及 float 转换为 int。前者是浮点类型之间的标准提升，被认为更加自然、安全；后者则涉及截断语义，因此优先级更低。结果是，哪怕你没有显式写出 float 版本，最终仍然会调用 process(double)。这也体现了一个事实：重载解析并不是"最少字符匹配"，而是"最合理的类型路径匹配"。
真正让人头疼的情况，往往出现在规则无法分出高下的时候。比如同时存在 func(int, double) 和 func(double, int) 两个重载，当你调用 func(5, 5) 时，两个候选函数的匹配成本是完全一样的——对于第一个版本，一个参数是精确匹配、另一个需要标准转换；对于第二个版本，情况正好对称。两边的"代价"一模一样，编译器不会试图揣测你的意图，而是直接判定调用存在歧义，以编译错误终止。
这背后反映的是 C++ 一个非常重要的设计理念：只要存在同样可行、但无法比较优劣的选择，编译器宁可拒绝编译，也不会替程序员做决定。这也是 C++ 强类型系统的底色——明确性永远高于便利性。从实践角度来说，我们在设计接口时，应当尽量避免仅靠参数顺序或微妙的类型差异来区分重载，尤其是在涉及内置类型或隐式转换时。一旦出现歧义，最可靠的做法永远是把类型写清楚。
如果要用一句话总结这一节，那就是：重载解析不是智能推断，而是一套冷静、刻板的规则系统；当你觉得"它应该能工作"的时候，往往正是它最容易报错的时候。
1.3 重载在嵌入式中的实际应用
在嵌入式开发中，函数重载最常见的应用场景是"统一不同数据类型的硬件操作接口"。比如，一个通用的数据发送函数，可能需要支持不同类型的输入：
class Logger {
public:
void log(int value) {
printf("[INFO] %d\n", value);
}
void log(float value) {
printf("[INFO] %.2f\n", value);
}
void log(const char* message) {
printf("[INFO] %s\n", message);
}
void log(const uint8_t* data, size_t length) {
printf("[INFO] Data (%zu bytes): ", length);
for (size_t i = 0; i < length; ++i) {
printf("%02X ", data[i]);
}
printf("\n");
}
};
// 使用
Logger logger;
logger.log(42); // [INFO] 42
logger.log(25.5f); // [INFO] 25.50
logger.log("System started"); // [INFO] System started
uint8_t packet[] = {0x01, 0x02};
logger.log(packet, 2); // [INFO] Data (2 bytes): 01 02调用者完全不需要关心 log 内部对每种类型做了什么处理——接口是统一的，但行为是针对类型的。这在 C 里就需要 log_int()、log_float()、log_string()、log_bytes() 四个不同的名字了。
不过，函数重载也不是万能的。它有一个从不同层面会带来麻烦的特性——导出符号。由于重载函数在编译后的符号名会被"修饰"（name mangling，编译器用一种编码规则把参数类型信息嵌入到最终符号名中），如果你在 C 代码中调用 C++ 的重载函数，或者在动态库的导出接口中使用重载，符号解析就会变成一个需要特别处理的问题。通常的做法是在需要被 C 代码调用的函数声明前加上 extern "C"，但 extern "C" 和函数重载是互斥的——因为 C 没有重载，自然也没有 name mangling。如果你的接口需要同时被 C 和 C++ 调用，重载就不太合适了。
2. 默认参数 (Default Arguments)
2.1 为什么需要默认参数
在真实工程中，函数参数并不是"越多越好"。很多时候，一个函数的参数里总会混着几类角色：核心必选参数——每次调用都不同；高频但几乎不变的配置——绝大多数场景下取固定值；以及只有极少数场景才会调整的高级选项。如果每次调用都被迫把这些参数一个不落地写出来，不仅代码冗长，而且会迅速掩盖真正重要的信息。
默认参数正是为了解决这个问题而存在的——那些你已经决定好"默认行为"的参数，就干脆别让调用者操心。
一个嵌入式开发中非常典型的例子是 UART 配置。真正每次都会变的，往往只有波特率；至于数据位、停止位、校验位，大多数项目里几乎一成不变。用默认参数，我们可以把"常识"编码进接口里：
void configure_uart(int baudrate,
int databits = 8,
int stopbits = 1,
char parity = 'N') {
// 配置 UART
}这样一来，最常见的调用形式只剩下真正关心的那一个参数：
configure_uart(115200);而当你真的需要偏离默认行为时，可以逐步"向右展开"参数：
configure_uart(115200, 8); // 只改数据位
configure_uart(115200, 8, 2); // 改数据位和停止位
configure_uart(115200, 8, 2, 'E'); // 全部自定义从接口设计的角度看，这是一种非常温和的向前兼容手段：你可以不断在函数右侧追加新的可选能力，而不会破坏已有代码。
2.2 默认参数的规则
默认参数的语法看似简单，但它的规则其实非常严格，踩坑的人不在少数。
**规则一：默认参数必须从右向左连续出现。**编译器在处理函数调用时，只能通过"省略尾部参数"的方式来判断哪些值使用默认值。换句话说，你不能跳过中间的参数——如果要给第三个参数传值，前面的所有参数都必须显式给出。这也就意味着，如果你试图在某个有默认值的参数后面再放一个没有默认值的参数，编译器会直接拒绝。
// 正确：默认参数从右向左连续
void init_spi(int freq, int mode = 0, int bits = 8);
// 错误：非默认参数不能出现在默认参数后面
// void bad_init(int freq = 1000000, int mode, int bits); // 编译错误所以，在设计函数签名时，参数的排列顺序非常重要。一个实用的原则是：把最常需要自定义的参数放在最左边，把几乎不会变的参数放在最右边。
**规则二：默认参数只能被指定一次，而且应该放在声明处。**这一点在头文件与源文件分离的工程中尤为重要。默认值是接口的一部分，而不是实现细节——如果你在 .cpp 里又写了一遍默认参数，编译器会认为你在试图重新定义规则，直接报错。
// uart.h —— 声明时指定默认参数
void configure_uart(int baudrate, int databits = 8, int stopbits = 1);
// uart.cpp —— 定义时不要重复默认参数
void configure_uart(int baudrate, int databits, int stopbits) {
// 实现
}如果有人在 .cpp 文件里这样写：
// 错误！默认参数不能同时在声明和定义中出现
void configure_uart(int baudrate, int databits = 8, int stopbits = 1) {
// 实现
}编译器会直接给你一个重定义默认参数的错误。这个坑在新手中非常常见——"声明处写了默认值、定义处又写了一遍"，而且报错信息有时候并不那么直观，定位起来还挺费劲的。
2.3 默认参数在嵌入式中的应用
在嵌入式开发中，默认参数特别适合用在"配置型接口"和"初始化函数"上。SPI、I2C、定时器这类外设，往往都有一套"推荐配置"，只有在极少数情况下才需要完全自定义。通过默认参数，最常见的用法几乎零负担：
// SPI 初始化：频率必须指定，其他参数几乎不变
void spi_init(int frequency, int mode = 0, int bit_order = 1);
// 使用
spi.init(); // 编译错误：频率是必选参数
spi.init(2000000); // 只指定频率，其他用默认值
spi.init(2000000, 3); // 指定频率和模式这种接口的可读性非常强：调用点本身就已经在"讲故事"，而不是一串神秘的魔法数字。
3. 重载 vs 默认参数：什么时候用哪个
函数重载和默认参数都能让接口更灵活，但它们的适用场景并不完全重叠。选择用哪一个，取决于你面对的具体问题。
当你需要处理不同类型的参数时，函数重载是唯一的选择——默认参数做不到这一点。比如 print(int) 和 print(const char*)，它们的参数类型完全不同，行为也不同，这只能用重载来实现。
当你需要减少参数数量、提供默认行为时，默认参数是更简洁的选择。比如 configure_uart(115200) 和 configure_uart(115200, 8, 2, 'E')，它们做的是同一件事，只是详细程度不同，用默认参数最自然。
但最需要警惕的情况是两者混用。函数重载和默认参数如果设计不当，会产生非常棘手的歧义问题。看下面这个经典的反面教材：
void process(int value) {
printf("Single: %d\n", value);
}
void process(int value, int factor = 2) {
printf("Scaled: %d\n", value * factor);
}
process(10); // 歧义！调用第一个？还是第二个（使用默认参数）？编译器在面对 process(10) 时，发现两个版本都能匹配——第一个是精确匹配，第二个也是精确匹配（只是第二个参数用了默认值）。这种情况下，编译器无法做出选择，直接报歧义错误。
这个例子说明了一个重要的设计原则：重载和默认参数不要在同一个接口上重叠。如果你发现自己在"是不是应该给这个重载版本加个默认参数"上犹豫，那很可能说明你的接口设计需要重新思考了。
笔者的建议是：对于同一个函数名，要么只用重载（多个版本参数类型不同），要么只用默认参数（一个版本部分参数有默认值），但不要两者混搭。如果确实需要同时支持"不同类型"和"不同参数数量"，可以考虑把不同类型的处理逻辑封装成不同的函数名——这虽然看起来不如重载"优雅"，但至少不会产生歧义。
小结
这一章我们学习了 C++ 在函数接口设计上的两个重要工具。函数重载允许同名函数根据参数类型和数量的不同而表现出不同的行为，编译器通过一套严格的"重载解析"规则来决定最终调用哪个版本。默认参数则让调用者可以省略那些"几乎总是同一个值"的尾部参数，让接口更简洁、更向前兼容。
两者都是让 API 更好用的利器，但也有各自的边界——重载擅长处理"类型不同"，默认参数擅长处理"参数可选"。当两者发生冲突时，优先保持接口的清晰性，而不是追求花哨的语法糖。
在下一篇中，我们将进入 C++ 的核心领域——类与对象。如果说命名空间、引用、函数重载还只是让 C++ 成为"更好的 C"，那么类才是 C++ 真正脱胎换骨的地方。