C/C++ 函数指针应用场景详解

C/C++ 函数指针应用场景详解

• 1、 回调函数 (Callback Functions)
• 2、事件处理与消息传递
• 3、动态函数调用（函数表/跳转表）
• 4、实现策略模式 (Strategy Pattern)
• 5、 状态机 (State Machines)
• 6、线程创建 (Thread Creation)
• 7、总结

1、 回调函数 (Callback Functions)

应用场景： 这是函数指针最经典的应用。允许一个函数（通常是库函数或框架函数）在执行过程中调用用户提供的另一个函数。例如，在排序算法中，用户可以提供自定义的比较规则；在事件处理系统中，用户注册处理函数来响应特定事件。

示例代码：

#include <stdio.h>
#include <stdlib.h>

// 定义比较函数的类型
typedef int (*CompareFunc)(const void*, const void*);

// 一个使用回调函数的排序函数 (简化版)
void sort_with_callback(int* array, int size, CompareFunc cmp) {
// 这里可以用qsort等，但为了演示我们自己实现一个简单的冒泡
for (int i = 0; i < size – 1; i++) {
for (int j = 0; j < size – i – 1; j++) {
if (cmp(&array[j], &array[j+1]) > 0) { // 使用回调比较
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
}

// 用户提供的比较函数1：升序
int compare_asc(const void* a, const void* b) {
int num_a = *(const int*)a;
int num_b = *(const int*)b;
return num_a – num_b;
}

// 用户提供的比较函数2：降序
int compare_desc(const void* a, const void* b) {
int num_a = *(const int*)a;
int num_b = *(const int*)b;
return num_b – num_a;
}

int main() {
int arr[] = {5, 2, 9, 1, 5};
int size = sizeof(arr) / sizeof(arr[0]);

// 使用升序比较回调
sort_with_callback(arr, size, compare_asc);
printf("Ascending: ");
for (int i = 0; i < size; i++) printf("%d ", arr[i]);
printf("\\n");

// 使用降序比较回调
sort_with_callback(arr, size, compare_desc);
printf("Descending: ");
for (int i = 0; i < size; i++) printf("%d ", arr[i]);
printf("\\n");

return 0;
}

说明： sort_with_callback 函数接受一个函数指针 cmp 作为参数。在排序过程中，它使用这个指针指向的函数来决定元素的顺序。用户可以根据需要传递不同的比较函数（compare_asc 或 compare_desc）来实现不同的排序行为。

2、事件处理与消息传递

应用场景： 在图形用户界面（GUI）编程、游戏引擎或网络库中，经常需要将特定事件（如鼠标点击、按键、收到网络包）与处理函数关联起来。函数指针可以用来存储和调用这些事件处理函数。

示例代码：

#include <iostream>
#include <map>
#include <string>

// 定义事件处理函数的类型
typedef void (*EventHandler)(const std::string& eventData);

// 一个简单的事件分发器类
class EventDispatcher {
public:
void registerEvent(const std::string& eventName, EventHandler handler) {
eventHandlers[eventName] = handler;
}

void triggerEvent(const std::string& eventName, const std::string& data) {
auto it = eventHandlers.find(eventName);
if (it != eventHandlers.end()) {
it->second(data); // 调用注册的处理函数
} else {
std::cout << "Event '" << eventName << "' not handled." << std::endl;
}
}

private:
std::map<std::string, EventHandler> eventHandlers;
};

// 用户定义的事件处理函数1
void handleClick(const std::string& data) {
std::cout << "Click event handled! Data: " << data << std::endl;
}

// 用户定义的事件处理函数2
void handleKeyPress(const std::string& data) {
std::cout << "KeyPress event handled! Data: " << data << std::endl;
}

int main() {
EventDispatcher dispatcher;

// 注册事件处理函数
dispatcher.registerEvent("click", handleClick);
dispatcher.registerEvent("keypress", handleKeyPress);

// 触发事件
dispatcher.triggerEvent("click", "Left button at (100, 200)");
dispatcher.triggerEvent("keypress", "Key: Enter");
dispatcher.triggerEvent("unknown", "Something"); // 未注册的事件

return 0;
}

说明： EventDispatcher 类维护了一个映射，将事件名称与对应的处理函数关联起来。当事件发生时，triggerEvent 方法查找并调用注册的函数指针指向的处理函数。

3、动态函数调用（函数表/跳转表）

应用场景： 当需要在运行时根据条件（如用户输入、配置、状态）选择调用不同的函数时，可以将函数指针存储在数组或结构体中，形成函数表（Function Table）或跳转表（Jump Table）。

示例代码：

#include <stdio.h>

// 定义数学运算函数类型
typedef double (*MathOperation)(double, double);

// 具体的运算函数
double add(double a, double b) { return a + b; }
double subtract(double a, double b) { return a – b; }
double multiply(double a, double b) { return a * b; }
double divide(double a, double b) { return (b != 0) ? a / b : 0.0; } // 简单处理除零

int main() {
// 创建一个函数指针数组 (函数表)
MathOperation operations[] = {add, subtract, multiply, divide};
const char* opNames[] = {"Add", "Subtract", "Multiply", "Divide"};

double num1, num2;
int choice;

printf("Enter two numbers: ");
scanf("%lf %lf", &num1, &num2);

printf("Choose operation:\\n");
for (int i = 0; i < sizeof(operations) / sizeof(operations[0]); i++) {
printf("%d. %s\\n", i + 1, opNames[i]);
}
scanf("%d", &choice);

if (choice > 0 && choice <= sizeof(operations) / sizeof(operations[0])) {
MathOperation op = operations[choice – 1]; // 获取函数指针
double result = op(num1, num2); // 动态调用
printf("Result: %.2lf\\n", result);
} else {
printf("Invalid choice!\\n");
}

return 0;
}

说明： 将四个不同的数学运算函数的地址存储在数组 operations 中。用户选择操作后，程序通过索引获取对应的函数指针并进行调用，避免了冗长的 if-else 或 switch-case 语句。

4、实现策略模式 (Strategy Pattern)

应用场景： 在面向对象设计中，策略模式允许在运行时选择算法或行为。在 C 中，虽然缺乏原生面向对象支持，但可以通过结构体包含函数指针来模拟策略接口。

示例代码：

#include <stdio.h>

// 定义策略接口 (结构体包含函数指针)
typedef struct {
void (*execute)(void* context); // 执行策略的函数指针
} Strategy;

// 具体策略A
void strategyA_execute(void* context) {
printf("Executing Strategy A. Context: %s\\n", (char*)context);
}

// 具体策略B
void strategyB_execute(void* context) {
printf("Executing Strategy B. Context: %s\\n", (char*)context);
}

// 使用策略的上下文
typedef struct {
Strategy currentStrategy;
char contextInfo[50];
} Context;

void setStrategy(Context* ctx, void (*func)(void*)) {
ctx->currentStrategy.execute = func;
}

void executeStrategy(Context* ctx) {
if (ctx->currentStrategy.execute) {
ctx->currentStrategy.execute(ctx->contextInfo);
}
}

int main() {
Context ctx;
snprintf(ctx.contextInfo, sizeof(ctx.contextInfo), "Some important data");

// 设置并使用策略A
setStrategy(&ctx, strategyA_execute);
executeStrategy(&ctx);

// 设置并使用策略B
setStrategy(&ctx, strategyB_execute);
executeStrategy(&ctx);

return 0;
}

说明： Strategy 结构体定义了一个“接口”（通过函数指针）。Context 结构体持有当前策略。通过 setStrategy 可以动态更换策略（设置不同的函数指针），然后通过 executeStrategy 执行当前策略。这实现了算法族的封装和动态切换。

5、 状态机 (State Machines)

应用场景： 在实现复杂的状态转换逻辑时，如协议解析、游戏 AI 状态管理。每个状态可以对应一个处理函数（状态处理函数），状态转换时改变当前指向的函数指针。

示例代码：

#include <stdio.h>

// 定义状态处理函数类型
typedef void (*StateHandler)(void);

// 状态处理函数
void state_idle(void) {
printf("State: Idle. Waiting for input…\\n");
// … 根据条件可能转换到其他状态
}

void state_processing(void) {
printf("State: Processing. Doing work…\\n");
// … 根据条件可能转换到其他状态
}

void state_finished(void) {
printf("State: Finished. Task completed.\\n");
// … 可能转换回Idle或其他
}

int main() {
StateHandler currentState = state_idle; // 初始状态

int input;
do {
// 执行当前状态的处理函数
currentState();

// 模拟外部输入或事件影响状态转换 (简化)
printf("Enter (1: process, 2: finish, 0: exit): ");
scanf("%d", &input);

// 根据输入转换状态 (这里逻辑很简单)
if (input == 1) {
currentState = state_processing;
} else if (input == 2) {
currentState = state_finished;
} else if (input == 0) {
break; // 退出
}
// 其他输入保持当前状态或根据实际需求转换
} while (1);

return 0;
}

说明： 变量 currentState 是一个函数指针，指向当前状态的处理函数。主循环中不断调用 currentState() 来执行当前状态的行为。根据输入（模拟事件），程序改变 currentState 的值，使其指向下一个状态的处理函数，从而实现了状态的迁移。

6、线程创建 (Thread Creation)

应用场景： 在 POSIX 线程（pthread）库中，创建新线程时需要指定线程启动后执行的函数，这正是通过函数指针实现的。

示例代码：

#include <stdio.h>
#include <pthread.h>

// 线程函数类型 (符合pthread_create要求的签名)
typedef void* (*ThreadFunc)(void*);

// 线程执行的任务函数
void* thread_task(void* arg) {
int* counter = (int*)arg;
for (int i = 0; i < 5; i++) {
(*counter)++;
printf("Thread counter: %d\\n", *counter);
}
return NULL;
}

int main() {
pthread_t thread_id;
int shared_counter = 0;

// 创建线程，传递函数指针 thread_task
if (pthread_create(&thread_id, NULL, thread_task, &shared_counter) != 0) {
perror("Failed to create thread");
return 1;
}

// 主线程也操作计数器
for (int i = 0; i < 3; i++) {
shared_counter += 10;
printf("Main counter: %d\\n", shared_counter);
}

// 等待线程结束
pthread_join(thread_id, NULL);

printf("Final counter value: %d\\n", shared_counter);
return 0;
}

说明： pthread_create 函数的第三个参数就是一个函数指针，它指向线程开始执行时要运行的函数（这里是 thread_task）。通过这种方式，操作系统能够知道新线程应该执行哪段代码。

7、总结

函数指针是 C/C++ 中一种强大的工具，它提供了在运行时动态决定调用哪个函数的能力，极大地增强了代码的灵活性和可扩展性。其主要应用场景包括：

• 回调机制： 实现库/框架与用户代码的交互。
• 事件驱动编程： 注册和调用事件处理函数。
• 动态函数选择： 通过函数表在运行时选择函数。
• 策略模式实现： 封装可互换的算法或行为。
• 状态机实现： 管理状态和状态转换逻辑。
• 线程入口点指定： 创建线程时指定其执行函数。