C++ 函数指针与回调函数深度解析

✅ 运行结果：

10 + 5 = 15
20 + 8 = 28
15 - 6 = 9

2.4 函数指针的类型匹配规则（关键！）

函数指针的类型必须与指向的函数完全匹配，包括：

1. 返回值类型一致（如 int 不能匹配 void，double 不能匹配 int）
2. 参数类型一致（如 int 不能匹配 double，参数个数必须相同）
3. const 修饰一致（如指向 const 函数的指针不能指向非 const 函数）

⚠️ 警告：类型不匹配的赋值会导致编译错误，或运行时不可预期的行为（如内存访问错误）。

💡 错误示例（类型不匹配）：

// 错误 1：返回值类型不匹配（函数返回 void，指针期望 int）
void printHello() {
    cout << "Hello" << endl;
}
int (*func1_ptr)() = printHello; // 编译错误：返回值类型不匹配

// 错误 2：参数个数不匹配（函数需 2 个参数，指针期望 1 个）
int multiply(int a, int b) {
    return a * b;
}
int (*func2_ptr)(int) = multiply; // 编译错误：参数个数不匹配

// 错误 3：参数类型不匹配（函数参数为 double，指针期望 int）
double divide(double a, double b) {
    return a / b;
}
int (*func3_ptr)(int, int) = divide; // 编译错误：参数类型不匹配

2.5 typedef 简化函数指针声明

复杂的函数指针声明（如参数较多或嵌套）可读性差，可使用 typedef 为函数指针类型定义别名，简化代码。

💡 示例：typedef 简化函数指针

#include <iostream>
using namespace std;

// 定义函数
int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

// 使用 typedef 定义函数指针类型别名：CalcFunc 是'int(int, int)'类型的函数指针别名
typedef int (*CalcFunc)(int, int);

int main() {
    // 直接使用别名声明函数指针，语法更简洁
    CalcFunc func_ptr;
    func_ptr = add;
    cout << "3 + 4 = " << func_ptr(3, 4) << endl;
    // 输出：7
    
    func_ptr = subtract;
    cout << "9 - 2 = " << func_ptr(9, 2) << endl;
    // 输出：7
    
    return 0;
}

💡 C++11 及以上也可使用 using 定义别名（更直观，推荐）：

// 等价于 typedef int (*CalcFunc)(int, int);
using CalcFunc = int(*)(int, int);

三、函数指针的核心应用场景

函数指针的核心价值是'解耦'和'灵活切换'，以下是 C++ 开发中最常见的应用场景：

3.1 场景 1：实现函数回调（核心场景）

回调函数是指通过函数指针将函数作为参数传递给另一个函数，在合适的时机由被调用函数触发执行的函数。函数指针是回调机制的底层实现基础，广泛用于事件处理、框架设计、算法注入等场景。

💡 示例：回调函数实现通用计算器

#include <iostream>
using namespace std;

// 定义函数指针类型别名
using CalcFunc = int(*)(int, int);

// 通用计算函数：接收两个操作数和一个回调函数，通过回调函数实现不同运算
int calculate(int a, int b, CalcFunc callback) {
    // 校验回调函数指针非空（避免空指针调用）
    if (callback == nullptr) {
        cout << "错误：回调函数指针为空！" << endl;
        return 0;
    }
    // 调用回调函数，实现灵活运算
    return callback(a, b);
}

// 具体运算函数（回调函数）
int add(int a, int b) { return a + b; }
int subtract(int a, int b) { return a - b; }
int multiply(int a, int b) { return a * b; }
int divide(int a, int b) {
    if (b == 0) {
        cout << "错误：除数不能为 0！" << endl;
        return 0;
    }
    return a / b;
}

int main() {
    int x = 20, y = 5;
    // 传递 add 作为回调函数
    cout << x << " + " << y << " = " << calculate(x, y, add) << endl;
    // 25
    // 传递 subtract 作为回调函数
    cout << x << " - " << y << " = " << calculate(x, y, subtract) << endl;
    // 15
    // 传递 multiply 作为回调函数
    cout << x << " * " << y << " = " << calculate(x, y, multiply) << endl;
    // 100
    // 传递 divide 作为回调函数
    cout << x << " / " << y << " = " << calculate(x, y, divide) << endl;
    // 4
    // 传递空指针（测试错误处理）
    calculate(x, y, nullptr);
    // 输出错误提示
    return 0;
}

✅ 运行结果：

20 + 5 = 25
20 - 5 = 15
20 * 5 = 100
20 / 5 = 4
错误：回调函数指针为空！

3.2 场景 2：实现函数表（跳转表）

函数表是存储函数指针的数组，通过索引快速切换并调用不同函数，适用于多分支场景（替代 switch-case，提高代码可维护性）。

💡 示例：函数表实现菜单命令处理

#include <iostream>
using namespace std;

// 定义函数指针类型：无参数、无返回值
using CommandFunc = void(*)();

// 具体命令函数
void cmd_new() { cout << "执行【新建文件】命令" << endl; }
void cmd_open() { cout << "执行【打开文件】命令" << endl; }
void cmd_save() { cout << "执行【保存文件】命令" << endl; }
void cmd_exit() { cout << "执行【退出程序】命令" << endl; }

int main() {
    // 函数表：存储命令函数指针的数组
    CommandFunc cmd_table[] = {
        cmd_new, // 索引 0：新建
        cmd_open, // 索引 1：打开
        cmd_save, // 索引 2：保存
        cmd_exit // 索引 3：退出
    };
    
    int choice;
    while (true) {
        // 显示菜单
        cout << "\n===== 菜单 =====" << endl;
        cout << "0. 新建文件" << endl;
        cout << "1. 打开文件" << endl;
        cout << "2. 保存文件" << endl;
        cout << "3. 退出程序" << endl;
        cout << "请输入选择（0-3）：";
        cin >> choice;
        
        // 校验输入合法性
        if (choice < 0 || choice >= sizeof(cmd_table) / sizeof(cmd_table[0])) {
            cout << "输入错误，请重新选择！" << endl;
            continue;
        }
        
        // 通过函数表索引调用对应函数
        cmd_table[choice]();
        
        // 退出程序
        if (choice == 3) break;
    }
    return 0;
}

✅ 运行结果：

===== 菜单 =====
0. 新建文件
1. 打开文件
2. 保存文件
3. 退出程序
请输入选择（0-3）：0
执行【新建文件】命令
...

3.3 场景 3：结合类成员函数（注意事项）

普通函数指针不能直接指向类的非静态成员函数，因为非静态成员函数隐含一个 this 指针参数（指向类实例），导致函数指针类型不匹配。需使用'成员函数指针'专门指向类成员函数。

💡 示例：类成员函数指针的使用

#include <iostream>
using namespace std;

class MathUtil {
public:
    // 非静态成员函数（隐含 this 指针）
    int add(int a, int b) { return a + b; }
    int multiply(int a, int b) { return a * b; }
    
    // 静态成员函数（无 this 指针，可直接用普通函数指针指向）
    static int subtract(int a, int b) { return a - b; }
};

int main() {
    // 1. 非静态成员函数指针：需指定类名，语法格式：返回值类型 (类名::*指针名)(参数列表)
    int (MathUtil::*mem_func_ptr)(int, int);
    
    // 初始化：指向 MathUtil 的 add 成员函数
    mem_func_ptr = &MathUtil::add;
    // 类成员函数必须加&
    
    // 调用：必须通过类实例（this 指针需要绑定实例）
    MathUtil math;
    int result1 = (math.*mem_func_ptr)(10, 3);
    // 语法：(实例.*指针名)(参数)
    cout << "10 + 3 = " << result1 << endl;
    // 13
    
    // 重新赋值为 multiply 成员函数
    mem_func_ptr = &MathUtil::multiply;
    int result2 = (math.*mem_func_ptr)(10, 3);
    cout << "10 * 3 = " << result2 << endl;
    // 30
    
    // 2. 静态成员函数指针：普通函数指针即可（无 this 指针）
    int (*static_func_ptr)(int, int) = &MathUtil::subtract;
    int result3 = static_func_ptr(10, 3);
    cout << "10 - 3 = " << result3 << endl;
    // 7
    
    return 0;
}

⚠️ 注意事项：

• 非静态成员函数指针的声明必须包含 类名::，调用时必须绑定类实例（(实例.*指针名)(参数) 或 (指针->*指针名)(参数)）
• 静态成员函数无 this 指针，可直接用普通函数指针指向，无需绑定实例

3.4 场景 4：函数指针与动态库（进阶应用）

在 Windows/Linux 平台下，可通过函数指针调用动态库（.dll/.so）中的导出函数，实现'运行时加载动态库'的灵活架构（插件化开发核心）。

💡 示例：Windows 平台动态库函数调用（简化版）

#include <iostream>
#include <windows.h>
// Windows 动态库相关头文件
using namespace std;

// 定义函数指针类型（与动态库导出函数匹配）
typedef int (*AddFunc)(int, int);

int main() {
    // 1. 加载动态库（.dll 文件路径）
    HMODULE hDll = LoadLibraryA("MathLib.dll");
    if (hDll == nullptr) {
        cout << "加载动态库失败！" << endl;
        return 1;
    }
    
    // 2. 获取动态库中导出函数的地址（函数名必须与导出时一致）
    AddFunc add = (AddFunc)GetProcAddress(hDll, "add");
    if (add == nullptr) {
        cout << "获取函数地址失败！" << endl;
        FreeLibrary(hDll); // 释放动态库
        return 1;
    }
    
    // 3. 通过函数指针调用动态库函数
    int result = add(100, 200);
    cout << "100 + 200 = " << result << endl;
    // 300
    
    // 4. 释放动态库（避免内存泄漏）
    FreeLibrary(hDll);
    return 0;
}

⚠️ 说明：动态库需导出函数（如 Windows 中用 __declspec(dllexport)，Linux 中用 __attribute__((visibility("default")))），函数指针类型必须与导出函数严格匹配。

四、回调函数的进阶实现：从函数指针到 std::function

C++11 引入的 std::function 是通用的函数包装器，支持封装函数指针、函数对象、lambda 表达式等，相比原生函数指针更灵活、类型安全，且支持捕获上下文（如 lambda 捕获变量），是现代 C++ 中实现回调的首选方式。

4.1 std::function 的基本用法

std::function 的声明格式：std::function<返回值类型 (参数类型列表)> 变量名;

💡 示例：std::function 替代函数指针实现回调

#include <iostream>
#include <functional>
// 包含 std::function 头文件
using namespace std;

// 通用计算函数：使用 std::function 作为回调参数
int calculate(int a, int b, function<int(int, int)> callback) {
    if (!callback) {
        // 校验回调是否有效（比 nullptr 更直观）
        cout << "错误：回调函数无效！" << endl;
        return 0;
    }
    return callback(a, b);
}

// 普通函数
int add(int a, int b) { return a + b; }

// 函数对象（仿函数）
struct MultiplyFunc {
    int operator()(int a, int b) { return a * b; }
};

int main() {
    int x = 15, y = 3;
    
    // 1. 封装普通函数
    function<int(int, int)> func1 = add;
    cout << x << " + " << y << " = " << calculate(x, y, func1) << endl;
    // 18
    
    // 2. 封装函数对象
    MultiplyFunc multiply_obj;
    function<int(int, int)> func2 = multiply_obj;
    cout << x << " * " << y << " = " << calculate(x, y, func2) << endl;
    // 45
    
    // 3. 封装 lambda 表达式（最灵活，支持捕获上下文）
    int factor = 2;
    auto lambda_divide = [factor](int a, int b) {
        if (b == 0) return 0;
        return (a / b) * factor; // 捕获外部变量 factor
    };
    cout << "(" << x << " / " << y << ") * " << factor << " = " << calculate(x, y, lambda_divide) << endl;
    // 10
    
    return 0;
}

✅ 运行结果：

15 + 3 = 18
15 * 3 = 45
(15 / 3) * 2 = 10

4.2 std::function vs 原生函数指针

💡 推荐用法：

• 简单场景（无上下文捕获，仅普通函数）：可使用原生函数指针
• 现代 C++ 开发（需 lambda、函数对象，或需要捕获变量）：优先使用 std::function

五、函数指针使用的常见错误与规避方案

5.1 错误 1：空指针调用（崩溃风险）

原因：

函数指针未初始化（默认是野指针）或被赋值为 nullptr，直接调用会导致内存访问错误（程序崩溃）。

规避方案：

1. 函数指针声明后立即初始化（如赋值为具体函数，或显式赋值为 nullptr）
2. 调用前必须检查指针是否非空（if (func_ptr != nullptr) 或 if (callback)）

💡 示例：安全调用函数指针

int (*func_ptr)(int, int) = nullptr; // 显式初始化
if (func_ptr != nullptr) {
    // 调用前检查
    func_ptr(1, 2);
} else {
    cout << "函数指针未初始化！" << endl;
}

5.2 错误 2：类型不匹配（编译/运行错误）

原因：

函数指针的返回值类型、参数类型/个数与指向的函数不匹配，或非静态成员函数用普通函数指针指向。

规避方案：

1. 使用 typedef 或 using 定义函数指针类型别名，避免手动书写错误
2. 严格遵循'类型完全匹配'原则，非静态成员函数使用专门的成员函数指针
3. 现代 C++ 中优先使用 std::function，编译错误提示更清晰

5.3 错误 3：函数指针生命周期问题（悬垂指针）

原因：

函数指针指向的函数已被销毁（如动态库已卸载、局部函数指针指向栈上的函数对象），后续调用会导致非法访问。

规避方案：

1. 确保函数指针指向的函数生命周期长于指针的使用周期（如指向全局函数、静态函数）
2. 动态库卸载前，确保不再使用库中的函数指针
3. 避免函数指针指向局部函数对象（栈上对象，超出作用域后销毁）

5.4 错误 4：忽略 const 修饰（编译错误）

原因：

函数指针未加 const 修饰，却指向 const 函数（如 int (*func_ptr)(int) 指向 int func(const int a)）。

规避方案：

函数指针的参数 const 修饰需与指向的函数一致：

int func(const int a) {
    return a * 2;
}
// 正确：参数类型包含 const
int (*func_ptr)(const int) = func;
// 错误：参数类型无 const，与函数不匹配
// int (*func_ptr)(int) = func;

六、实战案例：函数指针 + 回调函数实现排序算法注入

6.1 问题描述

实现一个通用排序函数，支持对整数数组按升序或降序排序，排序规则通过回调函数注入（函数指针实现），提高代码复用性。

6.2 实现思路

1. 定义排序回调函数类型：接收两个 int 参数，返回 bool（表示第一个参数是否应排在第二个参数之前）
2. 实现通用排序函数（如冒泡排序），接收数组、数组长度、排序回调函数
3. 实现升序、降序两个具体的排序规则函数，作为回调函数传递给通用排序函数

6.3 代码实现

#include <iostream>
using namespace std;

// 1. 定义排序回调函数类型：bool(int a, int b)，返回 true 表示 a 应排在 b 前面
using CompareFunc = bool(*)(int, int);

// 2. 通用冒泡排序函数：通过回调函数注入排序规则
void bubble_sort(int arr[], int length, CompareFunc compare) {
    // 校验参数合法性
    if (arr == nullptr || length <= 1 || compare == nullptr) {
        return;
    }
    for (int i = 0; i < length - 1; ++i) {
        for (int j = 0; j < length - 1 - i; ++j) {
            // 调用回调函数，判断是否需要交换元素
            if (!compare(arr[j], arr[j + 1])) {
                // 交换元素
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

// 3. 具体排序规则函数（回调函数）
// 升序排序：a < b 时，a 应排在 b 前面
bool ascending(int a, int b) {
    return a < b;
}

// 降序排序：a > b 时，a 应排在 b 前面
bool descending(int a, int b) {
    return a > b;
}

// 辅助函数：打印数组
void print_array(int arr[], int length) {
    for (int i = 0; i < length; ++i) {
        cout << arr[i] << " ";
    }
    cout << endl;
}

int main() {
    int arr[] = {5, 2, 9, 1, 5, 6};
    int length = sizeof(arr) / sizeof(arr[0]);
    
    cout << "原始数组：";
    print_array(arr, length);
    // 5 2 9 1 5 6
    
    // 4. 传递升序回调函数
    bubble_sort(arr, length, ascending);
    cout << "升序排序后：";
    print_array(arr, length);
    // 1 2 5 5 6 9
    
    // 5. 传递降序回调函数
    bubble_sort(arr, length, descending);
    cout << "降序排序后：";
    print_array(arr, length);
    // 9 6 5 5 2 1
    
    return 0;
}

6.4 运行结果

原始数组：5 2 9 1 5 6
升序排序后：1 2 5 5 6 9
降序排序后：9 6 5 5 2 1

✅ 扩展：若需自定义排序规则（如按绝对值大小排序），只需新增一个回调函数，无需修改排序核心逻辑：

// 按绝对值升序排序
bool abs_ascending(int a, int b) {
    return abs(a) < abs(b);
}

// 使用新的排序规则
int arr2[] = {-3, 1, -5, 2};
bubble_sort(arr2, 4, abs_ascending);
print_array(arr2, 4);
// 1 2 -3 -5

七、总结

1. 函数指针是指向函数的指针变量，核心语法需遵循'返回值类型、参数类型完全匹配'原则，typedef/using 可简化声明。
2. 函数指针的核心应用是回调函数和函数表，实现代码解耦和灵活切换，广泛用于事件处理、框架设计、动态库调用等场景。
3. 类非静态成员函数需使用'成员函数指针'，且调用时必须绑定类实例；静态成员函数可直接用普通函数指针指向。
4. 现代 C++ 中，std::function 是更灵活的函数包装器，支持封装函数、lambda、函数对象，推荐替代原生函数指针实现回调。
5. 使用函数指针需规避空指针调用、类型不匹配、生命周期问题等常见错误，确保代码安全可靠。