C++算法
C++ 函数指针与回调函数深度解析
函数指针是指向函数的指针变量，存储函数入口地址。通过函数指针可实现回调机制、函数表及动态库调用，达到解耦目的。C++ 中需注意类型匹配规则，非静态成员函数需使用成员函数指针。现代 C++ 推荐使用 std::function 替代原生函数指针，支持 lambda 表达式及上下文捕获。常见错误包括空指针调用、类型不匹配及生命周期问题。实战案例展示了利用回调函数实现通用排序算法的注入方式，提升代码复用性。
函数指针是指向函数的指针变量，存储函数入口地址。通过函数指针可实现回调机制、函数表及动态库调用，达到解耦目的。C++ 中需注意类型匹配规则，非静态成员函数需使用成员函数指针。现代 C++ 推荐使用 std::function 替代原生函数指针，支持 lambda 表达式及上下文捕获。常见错误包括空指针调用、类型不匹配及生命周期问题。实战案例展示了利用回调函数实现通用排序算法的注入方式，提升代码复用性。
💡 核心重点：函数指针的类型匹配规则、回调函数的注册与执行流程、函数指针与现代 C++ 特性的结合
函数指针是指向函数的指针变量，本质是指针，但它存储的不是普通数据的地址，而是函数在内存中的入口地址。通过函数指针，我们可以间接调用函数，实现'以指针方式操作函数'的灵活编程模式。
🗄️ 类比理解：
int* p 指向 int 类型数据，通过 *p 访问数据int (*p)(int, int) 指向'参数为两个 int、返回值为 int'的函数，通过 p(1,2) 或 (*p)(1,2) 调用函数函数指针的声明需明确指定函数的返回值类型、参数列表类型，语法格式如下：
// 格式：返回值类型 (*指针变量名)(参数类型 1, 参数类型 2, ...); 返回值类型 (*func_ptr)(参数类型列表);
💡 语法解析：
(*func_ptr)：括号必须存在，表明 func_ptr 是指针变量（若无括号，int* func_ptr(int) 是返回 int* 的函数声明）参数类型列表：必须与指向的函数参数类型、个数完全一致返回值类型：必须与指向的函数返回值类型完全一致函数指针的初始化有两种方式：直接赋值函数名（函数名本质是函数入口地址），或使用 &函数名（取地址符可省略）。调用时可通过 指针变量名 (参数) 或 (*指针变量名)(参数) 两种方式。
💡 示例：基础函数指针的声明、初始化与调用
#include <iostream>
using namespace std;
// 定义一个加法函数
int add(int a, int b) {
return a + b;
}
// 定义一个减法函数
int subtract(int a, int b) {
return a - b;
}
int main() {
// 1. 声明函数指针：指向'参数为两个 int、返回值为 int'的函数
int (*calc_ptr)(int, int);
// 2. 初始化：赋值为 add 函数（&可省略）
calc_ptr = add;
// 等价写法：calc_ptr = &add;
// 3. 调用方式 1：指针变量名 (参数)
int result1 = calc_ptr(10, 5);
cout << "10 + 5 = " << result1 << endl;
// 输出：10 + 5 = 15
// 调用方式 2：(*指针变量名)(参数)（兼容 C 语言风格，C++ 中两种方式等价）
int result2 = (*calc_ptr)(20, 8);
cout << "20 + 8 = " << result2 << endl;
// 输出：20 + 8 = 28
// 4. 重新赋值为 subtract 函数，实现灵活切换
calc_ptr = subtract;
int result3 = calc_ptr(15, 6);
cout << "15 - 6 = " << result3 << endl;
// 输出：15 - 6 = 9
return 0;
}
✅ 运行结果：
10 + 5 = 15
20 + 8 = 28
15 - 6 = 9
函数指针的类型必须与指向的函数完全匹配，包括：
⚠️ 警告：类型不匹配的赋值会导致编译错误，或运行时不可预期的行为（如内存访问错误）。
💡 错误示例（类型不匹配）：
// 错误 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; // 编译错误：参数类型不匹配
复杂的函数指针声明（如参数较多或嵌套）可读性差，可使用 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++ 开发中最常见的应用场景：
回调函数是指通过函数指针将函数作为参数传递给另一个函数，在合适的时机由被调用函数触发执行的函数。函数指针是回调机制的底层实现基础，广泛用于事件处理、框架设计、算法注入等场景。
💡 示例：回调函数实现通用计算器
#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
错误：回调函数指针为空！
函数表是存储函数指针的数组，通过索引快速切换并调用不同函数，适用于多分支场景（替代 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
执行【新建文件】命令
===== 菜单 =====
0. 新建文件
1. 打开文件
2. 保存文件
3. 退出程序
请输入选择（0-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 指针，可直接用普通函数指针指向，无需绑定实例在 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")))），函数指针类型必须与导出函数严格匹配。
C++11 引入的 std::function 是通用的函数包装器，支持封装函数指针、函数对象、lambda 表达式等，相比原生函数指针更灵活、类型安全，且支持捕获上下文（如 lambda 捕获变量），是现代 C++ 中实现回调的首选方式。
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
| 对比维度 | 原生函数指针 | std::function |
|---|---|---|
| 灵活性 | 低（仅支持普通函数/静态成员函数） | 高（支持函数、函数对象、lambda、成员函数） |
| 类型安全 | 一般（编译时检查，报错信息不直观） | 高（编译时严格检查，报错信息清晰） |
| 上下文捕获 | 不支持（无法捕获外部变量） | 支持（通过 lambda 捕获变量） |
| 空值处理 | 需手动检查 nullptr | 支持 !callback 直接判断有效性 |
| 语法复杂度 | 低（简单场景易用） | 中（需包含头文件，声明格式类似） |
💡 推荐用法：
std::function函数指针未初始化（默认是野指针）或被赋值为 nullptr，直接调用会导致内存访问错误（程序崩溃）。
if (func_ptr != nullptr) 或 if (callback)）💡 示例：安全调用函数指针
int (*func_ptr)(int, int) = nullptr; // 显式初始化
if (func_ptr != nullptr) {
// 调用前检查
func_ptr(1, 2);
} else {
cout << "函数指针未初始化！" << endl;
}
函数指针的返回值类型、参数类型/个数与指向的函数不匹配，或非静态成员函数用普通函数指针指向。
typedef 或 using 定义函数指针类型别名，避免手动书写错误std::function，编译错误提示更清晰函数指针指向的函数已被销毁（如动态库已卸载、局部函数指针指向栈上的函数对象），后续调用会导致非法访问。
函数指针未加 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;
实现一个通用排序函数，支持对整数数组按升序或降序排序，排序规则通过回调函数注入（函数指针实现），提高代码复用性。
#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;
}
原始数组：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
typedef/using 可简化声明。std::function 是更灵活的函数包装器，支持封装函数、lambda、函数对象，推荐替代原生函数指针实现回调。通过本文学习，你应能熟练运用函数指针和回调函数解决实际开发中的解耦需求，并掌握现代 C++ 中 std::function 的使用技巧。下一篇将深入探讨 C++ 的模板编程基础，开启泛型编程的大门！
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online