嵌入式C语言：函数指针

byte轻骑兵

发布于 2026-01-21 14:53:42

760

函数指针是一种特殊类型的指针，它存储的是函数的入口地址。在 C 语言中，函数在内存中占据一段连续的空间，函数指针可以指向这个函数所在的内存地址，从而允许我们通过指针来调用该函数。在C/C++等编程语言中，函数指针是一个非常重要的概念，特别是在嵌入式系统、操作系统、图形界面库等复杂软件系统的开发中，函数指针被广泛使用。

一、函数指针的定义

函数指针的定义方式与普通指针类似，但需要在指针类型前加上函数的返回类型和参数列表。例如，定义一个指向返回值为int、参数为两个int的函数的指针，可以写成：

int (*func_ptr)(int, int);

int 是函数指针所指向的函数的返回类型。
(*func_ptr) 表明 func_ptr 是一个指针变量，它指向一个函数。
(int, int) 是所指向函数的参数列表，这里表示该函数接受两个 int 类型的参数。

二、函数指针的赋值

函数指针的赋值是指将一个函数的地址赋给一个函数指针变量。这种赋值允许通过函数指针来间接调用函数，在实现回调函数、事件处理、动态函数表等场景中非常有用。例如：

#include <stdio.h>

// 定义一个返回整型值，接受两个整型参数的函数指针类型
typedef int (*FuncPtrType)(int, int);

// 定义两个函数，它们都将被函数指针调用
int add(int a, int b) {
    return a + b;
}

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

int main() {
    // 声明一个函数指针变量
    FuncPtrType funcPtr;

    // 将add函数的地址赋给函数指针
    funcPtr = add;
    // 通过函数指针调用add函数
    printf("add(5, 3) = %d\n", funcPtr(5, 3)); // 输出: add(5, 3) = 8

    // 将subtract函数的地址赋给函数指针
    funcPtr = subtract;
    // 通过函数指针调用subtract函数
    printf("subtract(5, 3) = %d\n", funcPtr(5, 3)); // 输出: subtract(5, 3) = 2

    // 也可以使用typedef定义的类型来声明和初始化函数指针
    FuncPtrType anotherFuncPtr = add;
    printf("anotherFuncPtr(7, 4) = %d\n", anotherFuncPtr(7, 4)); // 输出: anotherFuncPtr(7, 4) = 11

    return 0;
}

这里只展示了函数指针的基本用法，包括声明、赋值和通过函数指针调用函数。在实际应用中，函数指针通常用于实现更复杂的机制，如回调函数和动态函数表。

三、通过函数指针调用函数

在嵌入式系统开发中，C语言中的函数指针经常被用来实现回调机制、中断服务例程的动态绑定、状态机的实现等高级功能。通过函数指针调用函数，可以增加代码的灵活性和可维护性。

使用函数指针调用函数的方式与普通函数调用类似，但需要通过指针来间接调用。例如：

#include <stdio.h>
 
// 定义一个函数指针类型，指向返回void、接受一个整型参数的函数
typedef void (*OperationFunctionType)(int);
 
// 定义两个将被函数指针调用的函数
void ledOn(int ledNumber) {
    printf("LED %d turned ON\n", ledNumber);
    // 在嵌入式系统中，这里可能会是设置某个GPIO引脚为高电平的代码
}
 
void ledOff(int ledNumber) {
    printf("LED %d turned OFF\n", ledNumber);
    // 在嵌入式系统中，这里可能会是设置某个GPIO引脚为低电平的代码
}
 
int main() {
    // 声明一个函数指针变量
    OperationFunctionType operation;
 
    // 将ledOn函数的地址赋给函数指针
    operation = ledOn;
    // 通过函数指针调用ledOn函数
    operation(1); // 输出: LED 1 turned ON
 
    // 将ledOff函数的地址赋给函数指针
    operation = ledOff;
    // 通过函数指针调用ledOff函数
    operation(2); // 输出: LED 2 turned OFF
 
    // 假设我们有一个状态机，根据当前状态选择不同的操作
    enum State {
        STATE_LED_ON,
        STATE_LED_OFF
    };
 
    enum State currentState = STATE_LED_ON;
 
    // 根据当前状态设置函数指针
    if (currentState == STATE_LED_ON) {
        operation = ledOn;
    } else {
        operation = ledOff;
    }
 
    // 执行当前状态对应的操作
    operation(3); // 因为currentState是STATE_LED_ON，所以输出: LED 3 turned ON
 
    // 假设状态改变
    currentState = STATE_LED_OFF;
 
    // 再次根据当前状态设置函数指针并执行操作
    if (currentState == STATE_LED_ON) {
        operation = ledOn;
    } else {
        operation = ledOff;
    }
 
    operation(4); // 因为currentState现在是STATE_LED_OFF，所以输出: LED 4 turned OFF
 
    return 0;
}

这里只例展示了在嵌入式系统中如何使用函数指针来增加代码的灵活性和可维护性。在实际应用中，函数指针可能会用于更复杂的场景，如中断服务例程的动态绑定、回调函数的实现等。

四、函数指针作为函数参数

函数指针可以作为另一个函数的参数，这样可以实现函数回调。例如：

#include <stdio.h>

// 函数指针作为参数
void operate(int (*func)(int, int), int a, int b) {
    int result = func(a, b);
    printf("Result: %d\n", result);
}

int add(int a, int b) {
    return a + b;
}

int multiply(int a, int b) {
    return a * b;
}

int main() {
    operate(add, 3, 5);
    operate(multiply, 3, 5);
    return 0;
}

operate 函数接受一个函数指针 func 作为参数，以及两个 int 类型的参数 a 和 b。
在 main 函数中，分别将 add 和 multiply 函数作为参数传递给 operate 函数，根据传入的不同函数指针，operate 函数可以执行不同的操作。

五、函数指针数组

函数指针可以存储在数组中，形成函数指针数组。并在需要时通过索引来调用它们。这种机制在状态机实现、事件处理系统、以及任何需要动态函数调用的场景中都非常有用。例如：

#include <stdio.h>

int add(int a, int b) {
    return a + b;
}

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

int main() {
    int (*func_arr[2])(int, int);
    func_arr[0] = add;
    func_arr[1] = subtract;

    int result1 = func_arr[0](5, 3);
    int result2 = func_arr[1](5, 3);

    printf("Add result: %d\n", result1);
    printf("Subtract result: %d\n", result2);
    return 0;
}

func_arr 是一个函数指针数组，它可以存储两个函数指针。
func_arr[0] 存储了 add 函数的地址，func_arr[1] 存储了 subtract 函数的地址。

五、函数指针的应用场景

以下是一些主要的应用场景总结。

5.1. 中断服务程序

在嵌入式系统中，中断服务程序（Interrupt Service Routine, ISR）是响应硬件中断而执行的函数。由于不同的中断可能需要执行不同的服务程序，因此可以将这些服务程序的地址存储在中断向量表中，而中断向量表通常是由函数指针构成的数组。当中断发生时，系统会根据中断类型跳转到相应的中断服务程序执行。例如：

#include <stdint.h>
#include <stdio.h>
 
// 假设的中断服务程序类型
typedef void (*ISRFunctionType)(void);
 
// 中断服务程序示例
void UART_ISR(void) {
    printf("UART Interrupt Service Routine\n");
    // UART中断处理代码
}
 
void Timer_ISR(void) {
    printf("Timer Interrupt Service Routine\n");
    // 定时器中断处理代码
}
 
ISRFunctionType interruptVectorTable[2] = {UART_ISR, Timer_ISR};
 
// 模拟中断处理函数（在实际系统中，这是由硬件触发的）
void handleInterrupt(uint8_t interruptNumber) {
    if (interruptNumber < sizeof(interruptVectorTable) / sizeof(ISRFunctionType)) {
        interruptVectorTable[interruptNumber]();
    }
}
 
int main() {
    // 模拟UART中断
    handleInterrupt(0);
    // 模拟定时器中断
    handleInterrupt(1);
    return 0;
}

5.2. 状态机实现

状态机是嵌入式系统中常用的设计模式，用于处理复杂的控制逻辑和事件处理。函数指针可以用于实现状态转移和状态对应的行为。通过函数指针数组或查找表，可以根据当前状态和事件快速找到并执行相应的状态转移函数和行为函数。

#include <stdio.h>
 
typedef void (*StateActionFunctionType)(void);
 
// 状态机状态
typedef enum {
    STATE_IDLE,
    STATE_PROCESSING,
    STATE_DONE
} StateType;
 
// 状态机事件
typedef enum {
    EVENT_START,
    EVENT_FINISH
} EventType;
 
// 状态行为函数
void idleAction(void) {
    printf("State: IDLE\n");
}
 
void processingAction(void) {
    printf("State: PROCESSING\n");
}
 
void doneAction(void) {
    printf("State: DONE\n");
}
 
// 状态转移表
StateActionFunctionType stateActions[3] = {idleAction, processingAction, doneAction};
 
// 状态转移函数（简单示例，不处理复杂逻辑）
void stateMachine(StateType* currentState, EventType event) {
    // 这里的转移逻辑非常简化，仅用于演示
    switch (*currentState) {
        case STATE_IDLE:
            if (event == EVENT_START) {
                *currentState = STATE_PROCESSING;
            }
            break;
        case STATE_PROCESSING:
            if (event == EVENT_FINISH) {
                *currentState = STATE_DONE;
            }
            break;
        case STATE_DONE:
            // 不处理新事件
            break;
    }
    // 执行当前状态的行为
    stateActions[*currentState]();
}
 
int main() {
    StateType currentState = STATE_IDLE;
    stateMachine(&currentState, EVENT_START);
    stateMachine(&currentState, EVENT_FINISH);
    return 0;
}

5.3. 回调函数

回调函数是一种通过函数指针调用的函数，它允许在某个事件发生时自动执行特定的代码。在嵌入式系统中，回调函数常用于处理异步事件，如定时器到期、串口数据接收等。通过注册回调函数，可以在事件发生时自动调用相应的处理函数，而无需在主循环中轮询事件状态。

#include <stdio.h>
 
// 回调函数类型
typedef void (*CallbackFunctionType)(int);
 
// 回调函数示例
void myCallback(int value) {
    printf("Callback function called with value: %d\n", value);
}
 
// 触发回调函数的函数
void triggerEvent(CallbackFunctionType callback, int value) {
    callback(value);
}
 
int main() {
    triggerEvent(myCallback, 42);
    return 0;
}

5.4. 动态内存管理

虽然嵌入式系统通常具有有限的内存资源，但在某些情况下仍然需要动态地分配和释放内存。函数指针可以用于实现动态内存管理算法，如内存池分配、堆栈分配等。这些算法通常通过函数指针来调用具体的内存分配和释放函数。

5.5. 算法选择和优化

在嵌入式系统中，不同的算法可能具有不同的性能和资源消耗。通过使用函数指针，可以在运行时动态地选择算法。此外，还可以利用函数指针来实现算法的优化，如通过比较不同算法的性能来选择最优算法，或者通过修改算法参数来优化性能。

5.6. 模块化和可移植性

函数指针有助于实现代码的模块化和可移植性。通过将功能封装在独立的函数中，并通过函数指针进行调用，可以方便地替换或更新功能模块，而无需修改整个系统的代码。此外，函数指针还可以用于实现跨平台的代码兼容性，通过为不同的平台提供不同的函数实现并通过函数指针进行调用。

5.7. 数据结构操作

在嵌入式系统中，复杂的数据结构（如链表、树等）通常需要进行各种操作（如插入、删除、遍历等）。函数指针可以用于实现这些操作，并将它们与数据结构本身分离。这样可以使数据结构更加通用和灵活，同时也有助于实现代码的复用和模块化。

八、高级用法

8.1. 函数指针作为结构体成员

可以将函数指针作为结构体的成员，使得结构体可以存储函数的操作，从而实现面向对象编程中的类和对象的部分概念。

#include <stdio.h>

// 函数指针类型
typedef void (*PrintFunction)(void);

// 结构体
typedef struct {
    PrintFunction print;
} Printer;

// 具体的打印函数
void print_hello(void) {
    printf("Hello, World!\n");
}

void print_goodbye(void) {
    printf("Goodbye, World!\n");
}

int main() {
    Printer p1 = {print_hello};
    Printer p2 = {print_goodbye};

    p1.print();  // 调用 print_hello
    p2.print();  // 调用 print_goodbye
    return 0;
}

8.2. 函数指针与多线程（在支持多线程的嵌入式系统中）

在支持多线程的嵌入式系统中，函数指针可以用于创建线程并指定线程要执行的函数。这在使用RTOS（实时操作系统）时很常见。

// 假设有一个RTOS提供的线程创建函数
// osThreadCreate(osThreadFunc_t threadFunc, void *argument, ...);

void threadFunction(void *argument) {
    // 线程执行的代码
}

int main() {
    // 创建线程，传递函数指针和参数
    osThreadCreate(threadFunction, NULL, ...);
    return 0;
}

上面的代码是一个概念性的示例，实际的RTOS API会有所不同。

8.3. 函数指针与面向对象编程（OOP）模拟

虽然C语言不是面向对象的，但可以通过结构体和函数指针来模拟OOP的概念，如封装、继承和多态。

typedef struct {
    void (*init)(void);
    void (*process)(int);
    void (*destroy)(void);
} BaseClass;

typedef struct {
    BaseClass base;
    int specificData;
} DerivedClass;

void baseInit(void) {
    // Base class initialization code
}

void baseProcess(int data) {
    // Base class process code
}

void baseDestroy(void) {
    // Base class destruction code
}

void derivedInit(void) {
    // Derived class specific initialization
    // Call base class initializer if needed
    baseInit();
}

void derivedProcess(int data) {
    // Derived class specific processing
    // Call base class process if needed
    baseProcess(data);
}

void derivedDestroy(void) {
    // Derived class specific destruction
    // Call base class destructor if needed
    baseDestroy();
}

int main() {
    DerivedClass obj;
    obj.base.init = derivedInit;
    obj.base.process = derivedProcess;
    obj.base.destroy = derivedDestroy;

    obj.base.init(); // Calls derivedInit
    obj.base.process(10); // Calls derivedProcess
    obj.base.destroy(); // Calls derivedDestroy

    return 0;
}

BaseClass 和 DerivedClass 通过结构体和函数指针模拟了继承和多态的概念。

8.4. 指向函数指针的指针

可以使用指向函数指针的指针，增加函数指针的间接性，这在一些复杂的函数指针操作中可能会用到。

#include <stdio.h>

// 函数声明
void function(void) {
    printf("Function called\n");
}

int main() {
    void (*func_ptr)(void) = function;
    void (**ptr_to_func_ptr)(void) = &func_ptr;

    // 调用函数
    (*ptr_to_func_ptr)();  // 调用 function
    return 0;
}

8.5. 复杂函数指针类型

可以定义复杂的函数指针类型，例如接受多个不同类型的参数，或返回复杂类型（如结构体指针）。

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

typedef struct {
    int data;
} Result;

// 函数指针类型，接受两个 int 并返回 Result 结构体指针
typedef Result* (*ComplexFunctionPtr)(int, int);

// 具体函数
Result* complex_function(int a, int b) {
    Result* result = (Result*)malloc(sizeof(Result));
    result->data = a + b;
    return result;
}

int main() {
    ComplexFunctionPtr func = complex_function;
    Result* r = func(3, 4);
    printf("Result: %d\n", r->data);
    free(r);
    return 0;
}

8.6. 函数指针与静态变量结合

函数指针可以与静态变量结合使用，用于实现状态保存和持续操作。

#include <stdio.h>

typedef void (*StateFunction)(void);

// 状态函数 1
void state1(void) {
    static int count = 0;
    count++;
    printf("State 1: %d\n", count);
}

// 状态函数 2
void state2(void) {
    static int count = 0;
    count++;
    printf("State 2: %d\n", count);
}

// 函数指针数组
StateFunction states[] = {state1, state2};

int main() {
    for (int i = 0; i < 5; i++) {
        states[i % 2]();
    }
    return 0;
}

九、注意事项

9.1. 内存管理

在嵌入式系统中，内存通常是有限的。确保函数指针不会指向无效或未分配的内存区域。
避免在动态内存分配中使用函数指针，除非能确保内存管理的正确性。

9.2. 中断和实时性

如果在中断服务程序（ISR）中使用函数指针，确保指向的函数是快速且确定性的，以避免影响系统的实时性能。
避免在ISR中修改函数指针，因为这可能导致不可预测的行为。

9.3. 函数指针的初始化

在使用函数指针之前，确保它已被正确初始化。未初始化的函数指针可能会导致程序崩溃或执行未定义的行为。
使用NULL值初始化未使用的函数指针，并在调用之前检查它们是否为NULL。

9.4. 类型安全

确保函数指针的类型与所指向的函数类型匹配。类型不匹配可能导致编译错误或运行时错误。
使用typedef来定义函数指针类型，以提高代码的可读性和可维护性。

9.5. 作用域和生命周期

注意函数指针的作用域和生命周期。确保在函数指针被调用时，它所指向的函数仍然是有效的。
避免在函数指针所指向的函数被卸载或删除后还使用该函数指针。

9.6. 多线程和并发

在多线程环境中，如果多个线程访问或修改同一个函数指针，需要采取适当的同步措施来避免竞态条件。
确保在修改函数指针时，没有其他线程正在使用它。

9.7. 调试和测试

使用调试工具来跟踪函数指针的值和调用情况。
对使用函数指针的代码进行充分的测试，以确保其在各种情况下都能正确工作。

9.8. 避免滥用

虽然函数指针提供了很大的灵活性，但过度使用可能会导致代码难以理解和维护。
在可能的情况下，考虑使用其他结构（如状态机、回调表等）来替代复杂的函数指针逻辑。

综上所述，函数指针在 C 语言中是一个强大的工具，它可以增加程序的灵活性和可扩展性，特别是在需要根据不同条件调用不同函数的情况下，或者需要将函数作为参数传递时，函数指针就显得尤为重要。通过灵活运用函数指针，可以使代码更加模块化，便于维护和扩展。

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2026-01-20，如有侵权请联系 cloudcommunity@tencent.com 删除

嵌入式

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度