函数指针的基本概念
函数指针是指向函数的指针。它可以用来存储函数的地址，并通过它调用该函数。函数指针的声明形式与普通指针不同，它需要指定函数的返回类型和参数列表。
声明形式：
返回类型 (*指针名)(参数列表);
示例：
int (*funcPtr)(int, int);
上面的代码声明了一个名为 funcPtr 的函数指针，它指向一个以两个 int 参数为输入，并返回 int 类型结果的函数。
函数指针的初始化：可以将一个函数的地址赋值给一个函数指针来进行初始化。
int add(int a, int b) {
return a + b;
}
int (*funcPtr)(int, int) = add;
函数指针的使用：通过函数指针调用函数，与通过函数名调用函数类似。
int result = funcPtr(2, 3); // 调用 add(2, 3)
使用 typedef 定义函数指针
使用 typedef 可以为函数指针声明一个别名，从而简化代码书写。
一般的形式如下：
typedef 返回类型 (*别名)(参数列表);
假设我们有一个简单的加法函数，返回两个整数的和。我们可以使用 typedef 来定义该函数指针的类型别名。
不使用 typedef 的方式：
#include <stdio.h>
int add(int a, int b) {
return a + b;
}
int main() {
int (*funcPtr)(int, int) = add; // 使用函数指针调用
printf("Result: %d\n", funcPtr(3, 4));
return 0;
}
使用 typedef 定义函数指针：
#include <stdio.h>
// 使用 typedef 定义函数指针类型别名
typedef int (*OperationFunc)(int, int);
int add(int a, int b) {
return a + b;
}
int main() {
OperationFunc funcPtr = add; // 直接使用类型别名
printf("Result: %d\n", funcPtr(3, 4));
return 0;
}
使用 typedef 后，代码变得更易读，特别是在代码中多次使用该函数指针时。
函数指针的典型应用场景
- 回调函数：在事件驱动编程中，函数指针常用于实现回调机制。例如，在一个按钮点击事件发生时，调用预先设定好的回调函数。
- 多态性：通过函数指针数组实现类似于面向对象编程中的多态性，可以根据不同的条件调用不同的函数。
- 动态选择函数：在程序运行时根据需要动态选择并调用特定的函数，而不是在编译时决定调用哪个函数。
函数指针的典型例程
例程1：实现简单的计算器
#include <stdio.h>
// 定义计算操作函数
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) { return a / b; }
int main() {
int (*operation)(int, int); // 声明函数指针
int a = 10, b = 5;
// 选择加法操作
operation = add;
printf("Add: %d + %d = %d\n", a, b, operation(a, b));
// 选择减法操作
operation = subtract;
printf("Subtract: %d - %d = %d\n", a, b, operation(a, b));
// 选择乘法操作
operation = multiply;
printf("Multiply: %d * %d = %d\n", a, b, operation(a, b));
// 选择除法操作
operation = divide;
printf("Divide: %d / %d = %d\n", a, b, operation(a, b));
return 0;
}
例程2：使用回调函数
#include <stdio.h>
// 回调函数类型
typedef void (*CallbackFunction)(int);
// 回调函数实现
void onEventTriggered(int eventCode) {
printf("Event triggered with code: %d\n", eventCode);
}
// 事件处理函数
void handleEvent(CallbackFunction callback, int eventCode) {
// 事件发生时调用回调函数
callback(eventCode);
}
int main() {
// 注册回调函数
handleEvent(onEventTriggered, 100);
return 0;
}
例程3：状态机的实现
状态机是一种常见的编程模式，特别是在嵌入式系统中。函数指针可以用来实现状态机中不同状态之间的转换。
#include <stdio.h>
// 定义状态函数指针类型
typedef void (*StateFunction)();
// 函数声明
void stateIdle();
void stateRunning();
void stateError();
// 状态机结构
StateFunction currentState; // 当前状态
// Idle 状态处理函数
void stateIdle() {
printf("System is idle.\n");
// 假设输入为启动信号，切换到运行状态
printf("Transitioning to Running state...\n");
currentState = stateRunning;
}
// Running 状态处理函数
void stateRunning() {
printf("System is running.\n");
// 假设输入为错误信号，切换到错误状态
printf("Transitioning to Error state...\n");
currentState = stateError;
}
// Error 状态处理函数
void stateError() {
printf("System encountered an error.\n");
// 假设输入为复位信号，切换回空闲状态
printf("Resetting to Idle state...\n");
currentState = stateIdle;
}
// 状态机驱动函数：根据当前状态调用相应的函数
void runStateMachine() {
while (1) {
currentState(); // 调用当前状态的处理函数
delay(1000); // 模拟延时1000ms，循环执行
}
}
int main() {
// 初始化为 Idle 状态
currentState = stateIdle;
// 运行状态机
runStateMachine();
return 0;
}
示例解析
- 函数指针 StateFunction：定义了一个类型StateFunction，这是一个指向无返回值、无参数的函数指针类型。每个状态处理函数的签名与此类型一致。
- currentState变量：currentState 是一个函数指针，表示当前状态对应的函数。状态机通过调用 currentState()来执行当前状态的动作。
- 状态处理函数：
- stateIdle：系统处于空闲状态，假设有外部输入启动信号，状态切换到stateRunning。
- stateRunning：系统处于运行状态，假设有错误发生，状态切换到 stateError。
- stateError：系统遇到错误，复位后状态返回到 stateIdle。
- 状态机驱动：
- runStateMachine函数负责运行状态机，通过调用 currentState() 来执行当前状态的处理逻辑。
- 每次状态的切换都通过修改 currentState 变量来完成，从而实现状态的动态变化。
示例总结：通过函数指针实现状态机是C语言中一个灵活而高效的编程模式。每个状态对应一个函数，通过函数指针动态调用当前状态的处理逻辑，并根据外部输入进行状态切换。这种设计方式不仅使代码清晰易懂，而且在需要扩展状态时非常便捷。
例程4：函数指针数组实现指令解析器
指令解析器是嵌入式系统、命令行工具以及各种交互式系统中常见的组件。它用于根据接收到的指令调用相应的处理函数。使用函数指针数组可以实现一个高效且易于扩展的指令解析器。
#include <stdio.h>
#include <string.h>
// 定义函数指针类型
typedef void (*CommandFunc)(int, int);
// 函数声明
void cmdAdd(int a, int b);
void cmdSubtract(int a, int b);
void cmdMultiply(int a, int b);
void cmdDivide(int a, int b);
void cmdInvalid(int a, int b); // 处理无效指令
// 函数实现
void cmdAdd(int a, int b) {
printf("Result of addition: %d\n", a + b);
}
void cmdSubtract(int a, int b) {
printf("Result of subtraction: %d\n", a - b);
}
void cmdMultiply(int a, int b) {
printf("Result of multiplication: %d\n", a * b);
}
void cmdDivide(int a, int b) {
if (b != 0) {
printf("Result of division: %d\n", a / b);
} else {
printf("Error: Division by zero!\n");
}
}
void cmdInvalid(int a, int b) {
printf("Invalid command!\n");
}
// 指令解析器：使用函数指针数组
void parseCommand(const char* cmd, int a, int b) {
// 定义指令名数组与相应的函数指针数组
const char* commands[] = {"add", "subtract", "multiply", "divide"};
CommandFunc functions[] = {cmdAdd, cmdSubtract, cmdMultiply, cmdDivide};
// 遍历命令数组并查找匹配项
for (int i = 0; i < sizeof(commands) / sizeof(commands[0]); i++) {
if (strcmp(cmd, commands[i]) == 0) {
functions[i](a, b); // 调用相应的函数
return;
}
}
cmdInvalid(a, b); // 如果找不到匹配的指令，调用无效指令处理函数
}
int main() {
// 示例输入
parseCommand("add", 10, 5); // 输出：Result of addition: 15
parseCommand("subtract", 10, 5); // 输出：Result of subtraction: 5
parseCommand("multiply", 10, 5); // 输出：Result of multiplication: 50
parseCommand("divide", 10, 5); // 输出：Result of division: 2
parseCommand("unknown", 10, 5); // 输出：Invalid command!
return 0;
}
示例解析
- 函数指针类型 CommandFunc：定义了一个函数指针类型，用于指向带有两个 int 参数且无返回值的函数。这些函数处理具体的指令操作。
- 指令处理函数：
- cmdAdd、cmdSubtract、cmdMultiply、cmdDivide 分别对应加、减、乘、除操作。
- cmdInvalid 用于处理无效的指令。
- 指令名数组 commands[] 和函数指针数组 functions[]：
- ommands[] 存储支持的指令名称。
- functions[] 存储与每个指令对应的处理函数。
- 指令解析函数 parseCommand：
- 接受指令字符串 cmd 及其参数 a 和 b。
- 通过遍历 commands[] 数组，查找与输入指令匹配的项。如果找到匹配项，则调用对应的函数。
- 如果没有匹配的指令，调用 cmdInvalid 函数处理无效指令。
示例总结：通过函数指针数组实现指令解析器，使得指令的解析与执行逻辑清晰简洁，同时也非常易于扩展。每个指令对应一个函数指针，通过指令字符串的索引直接调用相应的处理函数。这种设计模式在需要处理大量指令且需要灵活管理指令集的系统中非常有用。
例程5：函数指针数组实现策略模式
策略模式是一种行为设计模式，允许在运行时选择算法。可以使用函数指针来实现不同的策略，并根据需要选择不同的实现。
#include <stdio.h>
// 策略函数类型
typedef int (*StrategyFunction)(int, int);
// 策略函数实现
int strategyAdd(int a, int b) { return a + b; }
int strategyMultiply(int a, int b) { return a * b; }
int applyStrategy(StrategyFunction strategy, int a, int b) {
return strategy(a, b);
}
int main() {
int x = 10, y = 5;
// 使用加法策略
printf("Addition: %d\n", applyStrategy(strategyAdd, x, y));
// 使用乘法策略
printf("Multiplication: %d\n", applyStrategy(strategyMultiply, x, y));
return 0;
}
策略模式优点：
- 灵活性：可以在运行时动态更换策略，轻松应对需求变化。
- 扩展性强：添加新策略不影响现有代码，只需实现符合策略接口的新函数即可。
- 代码复用性高：上下文结构和函数可以在多种场景下重用，不需要为每个场景写不同的实现。
扩展应用：万能指针充当函数指针
在C语言中，void* 被称为“万能指针”，因为它可以指向任何类型的数据。我们可以通过强制类型转换（type casting）让 void* 充当函数指针。
万能指针 (void*) 的基本概念
void* 是一种特殊的指针类型，它可以存储任何类型的数据地址。由于它不携带具体类型信息，因此需要进行类型转换才能在使用中恢复原始类型。
示例：
void* ptr;
int a = 10;
ptr = &a; // ptr 可以指向 int 类型的变量
万能指针充当函数指针
虽然 void* 可以指向任何类型的地址，但在函数指针的上下文中使用 void* 需要非常小心。通常，我们需要将 void* 转换回具体的函数指针类型，然后再调用函数。
关键步骤：
- 将函数指针类型转换为 void*。
- 使用 void* 存储函数指针。
- 在调用时将 void* 转换回正确的函数指针类型。
例程：通用回调函数注册系统
我们将创建一个通用的回调系统，允许注册任意类型的回调函数，并在需要时调用这些函数。
#include <stdio.h>
// 定义一个回调函数类型
typedef int (*OperationFunc)(int, int);
// 函数实现
int add(int a, int b) {
return a + b;
}
int subtract(int a, int b) {
return a - b;
}
// 通用回调系统
typedef struct {
void* func; // 使用 void* 存储任意类型的函数指针
} CallbackSystem;
// 注册回调函数
void registerCallback(CallbackSystem* system, void* func) {
system->func = func; // 将函数指针存储为 void*
}
// 调用回调函数
int invokeCallback(CallbackSystem* system, int a, int b) {
// 通过类型转换恢复原始函数指针并调用
OperationFunc operation = (OperationFunc)system->func;
return operation(a, b);
}
int main() {
CallbackSystem system;
// 注册并调用加法操作
registerCallback(&system, (void*)add);
printf("Add: %d\n", invokeCallback(&system, 10, 5));
// 注册并调用减法操作
registerCallback(&system, (void*)subtract);
printf("Subtract: %d\n", invokeCallback(&system, 10, 5));
return 0;
}
示例解析
- void* 存储函数指针：CallbackSystem 结构体中的 func 成员使用 void* 存储任意类型的函数指针。
- 类型转换：在调用回调函数时，我们将 void* 转换回正确的函数指针类型（在本例中为 OperationFunc），然后调用它。
- 灵活性：这种方法使得系统可以存储和调用不同类型的函数指针，而不必在定义时知道具体的函数类型。
注意事项
- 安全性问题：使用 void* 来充当函数指针需要特别小心，因为错误的类型转换可能导致不可预见的行为或崩溃。
- 编译器检查缺失：由于 void* 是无类型的，编译器不会检查函数签名的匹配性，因此任何错误可能只会在运行时暴露。
扫一扫
757
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
