C++ 函数重载：规则、匹配与实战案例

#include <iostream>
#include <string>
using namespace std;

// 重载函数 1：两个 int 类型参数
void print(int a, int b) {
    cout << "两个整数：" << a << " " << b << endl;
}

// 重载函数 2：一个 string 类型参数
void print(string s) {
    cout << "字符串：" << s << endl;
}

int main() {
    // 精确匹配 print(int, int)
    print(10, 20);

    // 精确匹配 print(string)
    print("C++ Overload");
    return 0;
}

2. 提升匹配

如果参数类型可以进行隐式提升，编译器就会选择提升后的目标类型。常见的提升包括：

• char、short 提升为 int
• float 提升为 double

#include <iostream>
using namespace std;

void func(int a) {
    cout << "int 类型参数：" << a << endl;
}

void func(double b) {
    cout << "double 类型参数：" << b << endl;
}

int main() {
    char c = 'A';
    float f = 3.14f;

    // char 提升为 int，匹配 func(int)
    func(c);

    // float 提升为 double，匹配 func(double)
    func(f);
    return 0;
}

3. 转换匹配

当参数必须经过隐式类型转换才能匹配时，就属于转换匹配。它的优先级最低，也最容易引发歧义。

开发中要尽量少依赖这一层匹配，因为一旦存在多个可行候选，编译器就可能不知道该选谁。

#include <iostream>
using namespace std;

void func(long a) {
    cout << "long 类型参数：" << a << endl;
}

void func(double b) {
    cout << "double 类型参数：" << b << endl;
}

int main() {
    // int 可以转换为 long 或 double，编译错误：二义性
    // func(10);
    return 0;
}

三、函数重载与默认参数的冲突处理

重载和默认参数放在一起时，最容易出问题的地方就是：某个调用既能匹配一个带默认参数的函数，又能匹配另一个重载函数。这时编译器会直接报二义性。

1. 冲突场景示例

#include <iostream>
using namespace std;

void display(int a, int b = 10) {
    cout << "a = " << a << ", b = " << b << endl;
}

void display(int a) {
    cout << "a = " << a << endl;
}

int main() {
    // 编译错误：二义性，无法确定调用哪个 display
    display(5);
    return 0;
}

2. 常见的解决思路

• 调整函数参数列表，尽量避免参数数量和类型重叠
• 调用时显式传递所有参数，让匹配路径更明确
• 如果逻辑本身已经开始分叉，干脆拆开功能，不要勉强靠默认参数和重载一起扛

四、实战案例：用重载实现一个通用计算器

假设我们要做一个简单的计算器，支持整数和浮点数的加减乘除。这个场景很适合用重载来整理接口，因为不同数值类型的处理方式几乎一致，只是返回类型和除法细节略有不同。

1. 设计思路

• 定义两个 calculate 重载函数，分别处理 int 和 double
• 每个函数接收两个操作数和一个运算符，返回计算结果
• 对除法做边界检查，避免除数为 0

2. 完整实现

#include <iostream>
#include <stdexcept>
using namespace std;

// 整数运算重载函数
int calculate(int a, int b, char op) {
    switch (op) {
        case '+': return a + b;
        case '-': return a - b;
        case '*': return a * b;
        case '/':
            if (b == 0) {
                throw invalid_argument("除数不能为 0");
            }
            return a / b;
        default:
            throw invalid_argument("无效运算符");
    }
}

// 浮点数运算重载函数
double calculate(double a, double b, char op) {
    switch (op) {
        case '+': return a + b;
        case '-': return a - b;
        case '*': return a * b;
        case '/':
            if (b == 0.0) {
                throw invalid_argument("除数不能为 0");
            }
            return a / b;
        default:
            throw invalid_argument("无效运算符");
    }
}

int main() {
    try {
        // 调用 int 版本 calculate
        cout << "整数除法：" << calculate(10, 3, '/') << endl;

        // 调用 double 版本 calculate
        cout << "浮点数除法：" << calculate(10.0, 3.0, '/') << endl;

        // 测试除数为 0 的情况
        cout << calculate(5, 0, '/') << endl;
    } catch (const exception& e) {
        cout << "错误：" << e.what() << endl;
    }

    return 0;
}

3. 运行结果

整数除法：3
浮点数除法：3.33333
错误：除数不能为 0

这里有个细节值得留意：int 版本的除法是整数除法，结果会直接截断；而 double 版本保留了小数部分，所以输出会更完整。实际项目里，如果你希望统一行为，就要在接口设计阶段想清楚，不然很容易在测试时踩坑。

五、总结

函数重载的核心，是用参数列表区分同名函数，而不是靠返回值。编译器在选择重载时，会优先走精确匹配，再考虑提升匹配，最后才是转换匹配。和默认参数搭配时要格外小心，因为它们很容易把调用变成二义性。

在实际开发中，重载最适合用来整理那些'语义相同、输入略有差异'的接口。设计得好，代码会更简洁；设计得不够克制，就会把接口弄得很难读、也很难维护。