函数指针、指针函数与回调函数详解

原创于 2025-06-22 15:45:10 发布 · 830 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#c语言

ARM开发专栏收录该内容

7 篇文章

订阅专栏

函数指针、指针函数与回调函数详解及C语言实现

1. 指针函数（Function Returning Pointer）

概念解析

指针函数是返回指针类型的函数。本质上它是一个函数，但返回值是指针类型（如 int*, char* 等）。

特点

函数声明中返回类型为指针类型
通常用于动态内存分配、字符串操作等场景
调用者需负责管理返回的指针内存

C语言示例

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

// 指针函数示例1：创建动态数组
int* createIntArray(int size) {
    int* arr = (int*)malloc(size * sizeof(int));
    if (arr == NULL) return NULL;
    
    for (int i = 0; i < size; i++) {
        arr[i] = i * 10; // 初始化数组元素
    }
    return arr; // 返回指向动态数组的指针
}

// 指针函数示例2：字符串处理
char* reverseString(const char* str) {
    int len = strlen(str);
    char* reversed = (char*)malloc(len + 1);
    if (reversed == NULL) return NULL;
    
    for (int i = 0; i < len; i++) {
        reversed[i] = str[len - 1 - i];
    }
    reversed[len] = '\0'; // 字符串结束符
    return reversed; // 返回新字符串指针
}

// 指针函数示例3：查找最大值
int* findMax(int* arr, int size) {
    if (size <= 0) return NULL;
    
    int* maxPtr = &arr[0];
    for (int i = 1; i < size; i++) {
        if (arr[i] > *maxPtr) {
            maxPtr = &arr[i];
        }
    }
    return maxPtr; // 返回指向最大元素的指针
}

int main() {
    // 示例1：使用指针函数创建动态数组
    int* numbers = createIntArray(5);
    printf("动态数组: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", numbers[i]);
    }
    free(numbers); // 释放分配的内存
    
    // 示例2：使用指针函数反转字符串
    char* reversed = reverseString("Hello World");
    printf("\n反转字符串: %s", reversed);
    free(reversed); // 释放内存
    
    // 示例3：使用指针函数查找最大值
    int values[] = {12, 45, 8, 99, 23};
    int* max = findMax(values, 5);
    printf("\n最大值: %d (位置: %ld)", *max, max - values);
    
    return 0;
}

输出结果：

动态数组: 0 10 20 30 40 
反转字符串: dlroW olleH
最大值: 99 (位置: 3)

使用注意事项

内存管理：调用者负责释放动态分配的内存
空指针检查：始终检查返回值是否为NULL
生命周期：返回的指针指向的内存必须在有效期内使用

2. 函数指针（Pointer to Function）

概念解析

函数指针是指向函数的指针变量。它存储函数的入口地址，可以通过指针间接调用函数。

特点

声明语法特殊：返回类型 (*指针名)(参数列表)
实现运行时多态和动态绑定
常用于策略模式、回调机制等场景

C语言示例

#include <stdio.h>
#include <math.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; }
double divide(int a, int b) { 
    if (b == 0) return 0.0;
    return (double)a / b; 
}

// 计算器函数
void calculator(int x, int y, int (*intOp)(int, int)) {
    printf("运算结果: %d\n", intOp(x, y));
}

// 高级计算器（支持浮点运算）
void advancedCalculator(int x, int y, double (*doubleOp)(int, int)) {
    printf("高级运算结果: %.2f\n", doubleOp(x, y));
}

// 函数指针数组示例
double power(int base, int exp) { return pow(base, exp); }
double squareRoot(int num, int unused) { return sqrt(num); }

int main() {
    // 基本函数指针使用
    int (*operation)(int, int); // 声明函数指针
    
    operation = add;
    printf("10 + 5 = %d\n", operation(10, 5));
    
    operation = subtract;
    printf("10 - 5 = %d\n", operation(10, 5));
    
    operation = multiply;
    printf("10 * 5 = %d\n", operation(10, 5));
    
    // 函数指针作为参数
    calculator(15, 3, multiply);
    calculator(20, 4, subtract);
    
    // 支持不同返回类型的函数指针
    double (*doubleOperation)(int, int) = divide;
    printf("20 / 3 = %.2f\n", doubleOperation(20, 3));
    
    advancedCalculator(20, 3, divide);
    
    // 函数指针数组（跳转表）
    double (*mathOps[])(int, int) = {power, squareRoot};
    printf("2^8 = %.0f\n", mathOps[0](2, 8));
    printf("√64 = %.0f\n", mathOps[1](64, 0)); // 第二个参数未使用
    
    return 0;
}

输出结果：

10 + 5 = 15
10 - 5 = 5
10 * 5 = 50
运算结果: 45
运算结果: 16
20 / 3 = 6.67
高级运算结果: 6.67
2^8 = 256
√64 = 8

使用技巧

使用typedef简化复杂声明：

typedef double (*MathOperation)(int, int);
MathOperation op = power;

函数指针数组实现状态机：

void (*stateMachine[])(void) = {idleState, activeState, errorState};
int currentState = 0;
stateMachine[currentState](); // 执行当前状态

3. 回调函数（Callback Function）

概念解析

回调函数是通过函数指针调用的函数。它允许函数接收另一个函数作为参数，在特定事件发生时调用。

特点

实现控制反转（IoC）
支持事件驱动编程模型
提供扩展点和定制能力
核心机制是函数指针作为参数传递

C语言示例

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

// 回调函数类型定义
typedef void (*EventCallback)(const char* eventName, int eventData);
typedef void (*CompletionCallback)(int result, const char* error);

// 事件处理器框架
void registerEventHandler(EventCallback callback) {
    // 模拟事件发生
    const char* events[] = {"click", "keypress", "error"};
    srand(time(0));
    
    for (int i = 0; i < 5; i++) {
        int eventIdx = rand() % 3;
        int eventData = rand() % 100;
        callback(events[eventIdx], eventData); // 触发回调
    }
}

// 异步操作框架
void asyncOperation(int param, CompletionCallback callback) {
    printf("开始异步操作...\n");
    
    // 模拟耗时操作
    for (int i = 0; i < 3; i++) {
        printf("处理中...\n");
        sleep(1);
    }
    
    // 模拟操作结果
    if (param > 50) {
        callback(param * 2, NULL); // 成功回调
    } else {
        callback(0, "参数太小，操作失败"); // 失败回调
    }
}

// 实际的回调函数实现
void handleUIEvent(const char* eventName, int eventData) {
    printf("[UI事件] 类型: %s, 数据: %d\n", eventName, eventData);
}

void handleSystemEvent(const char* eventName, int eventData) {
    printf("[系统事件] %s: %d\n", eventName, eventData);
}

void operationCompleted(int result, const char* error) {
    if (error) {
        printf("操作失败! 错误: %s\n", error);
    } else {
        printf("操作成功! 结果: %d\n", result);
    }
}

// 排序算法使用回调
void bubbleSort(int arr[], int size, int (*compare)(int, int)) {
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            if (compare(arr[j], arr[j+1]) > 0) {
                // 交换元素
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

// 比较函数
int ascending(int a, int b) { return a - b; }
int descending(int a, int b) { return b - a; }

int main() {
    // 事件回调示例
    printf("=== 事件处理回调 ===\n");
    registerEventHandler(handleUIEvent);
    printf("\n");
    registerEventHandler(handleSystemEvent);
    
    // 异步操作回调示例
    printf("\n=== 异步操作回调 ===\n");
    asyncOperation(70, operationCompleted);
    asyncOperation(30, operationCompleted);
    
    // 排序算法回调示例
    printf("\n=== 排序算法回调 ===\n");
    int numbers[] = {34, 7, 23, 32, 5, 62};
    int size = sizeof(numbers)/sizeof(numbers[0]);
    
    printf("原始数组: ");
    for (int i = 0; i < size; i++) printf("%d ", numbers[i]);
    
    bubbleSort(numbers, size, ascending);
    printf("\n升序排序: ");
    for (int i = 0; i < size; i++) printf("%d ", numbers[i]);
    
    bubbleSort(numbers, size, descending);
    printf("\n降序排序: ");
    for (int i = 0; i < size; i++) printf("%d ", numbers[i]);
    
    return 0;
}

输出示例：

=== 事件处理回调 ===
[UI事件] 类型: keypress, 数据: 42
[UI事件] 类型: click, 数据: 17
[UI事件] 类型: click, 数据: 85
[UI事件] 类型: error, 数据: 3
[UI事件] 类型: click, 数据: 71

[系统事件] keypress: 86
[系统事件] click: 15
[系统事件] keypress: 92
[系统事件] click: 49
[系统事件] error: 20

=== 异步操作回调 ===
开始异步操作...
处理中...
处理中...
处理中...
操作成功! 结果: 140
开始异步操作...
处理中...
处理中...
处理中...
操作失败! 错误: 参数太小，操作失败

=== 排序算法回调 ===
原始数组: 34 7 23 32 5 62 
升序排序: 5 7 23 32 34 62 
降序排序: 62 34 32 23 7 5

回调函数的实际应用场景

GUI事件处理：

void registerButtonClick(void (*handler)(int x, int y));

定时器/中断处理：

void setTimer(int milliseconds, void (*callback)(void));

I/O完成通知：

void readFile(const char* filename, void (*completion)(char* data, int size));

算法定制（如qsort）：

qsort(values, count, sizeof(int), (int (*)(const void*, const void*))compareInts);

插件系统：

void registerPlugin(const char* name, void (*init)(), void (*run)());

三者的关系与区别

特性	指针函数	函数指针	回调函数
本质	函数	指针	编程模式
定义	`int* func()`	`int (*ptr)()`	函数指针的应用
主要用途	返回动态创建的数据	间接调用函数	实现扩展点和事件处理
内存	函数代码 + 返回指针	指针变量（4/8字节）	依赖函数指针
调用方式	直接调用：`int* p = func()`	间接调用：`ptr()`	由框架/库函数调用
典型场景	工厂函数、字符串处理	策略模式、状态机	事件处理、异步编程

关键区别图示

高级应用：三者的结合使用

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

// 回调函数类型
typedef void (*DataProcessor)(int* data, int size);

// 指针函数：创建数据处理函数
DataProcessor getProcessor(int type) {
    // 函数指针数组
    static void (*processors[])(int*, int) = {
        [0] = sortAscending,
        [1] = sortDescending,
        [2] = doubleValues
    };
    
    if (type < 0 || type > 2) return NULL;
    return processors[type];
}

// 数据处理函数实现
void sortAscending(int* data, int size) {
    // 简单冒泡排序
    for (int i = 0; i < size-1; i++) {
        for (int j = 0; j < size-i-1; j++) {
            if (data[j] > data[j+1]) {
                int temp = data[j];
                data[j] = data[j+1];
                data[j+1] = temp;
            }
        }
    }
}

void sortDescending(int* data, int size) {
    for (int i = 0; i < size-1; i++) {
        for (int j = 0; j < size-i-1; j++) {
            if (data[j] < data[j+1]) {
                int temp = data[j];
                data[j] = data[j+1];
                data[j+1] = temp;
            }
        }
    }
}

void doubleValues(int* data, int size) {
    for (int i = 0; i < size; i++) {
        data[i] *= 2;
    }
}

// 处理数据的函数（接收回调）
void processData(int* data, int size, DataProcessor processor) {
    printf("处理前: ");
    for (int i = 0; i < size; i++) printf("%d ", data[i]);
    
    processor(data, size); // 调用回调函数
    
    printf("\n处理后: ");
    for (int i = 0; i < size; i++) printf("%d ", data[i]);
    printf("\n");
}

int main() {
    int data[] = {5, 2, 8, 1, 9};
    int size = sizeof(data)/sizeof(data[0]);
    
    // 获取不同的处理器（函数指针）
    DataProcessor processor = getProcessor(0); // 升序排序
    if (processor) processData(data, size, processor);
    
    processor = getProcessor(1); // 降序排序
    if (processor) processData(data, size, processor);
    
    processor = getProcessor(2); // 加倍数值
    if (processor) processData(data, size, processor);
    
    return 0;
}

输出结果：

处理前: 5 2 8 1 9 
处理后: 1 2 5 8 9 

处理前: 1 2 5 8 9 
处理后: 9 8 5 2 1 

处理前: 9 8 5 2 1 
处理后: 18 16 10 4 2

总结

指针函数：
- 本质：返回指针的函数
- 用途：创建动态数据结构，返回处理结果
- 关键：调用者负责内存管理
函数指针：
- 本质：指向函数的指针变量
- 用途：实现策略模式、动态绑定
- 关键：提供运行时灵活性
回调函数：
- 本质：通过函数指针实现的编程模式
- 用途：事件处理、异步编程、算法定制
- 关键：实现控制反转（IoC）

在实际开发中，这三者经常结合使用：

指针函数可以返回函数指针
回调函数的核心机制是函数指针
函数指针使回调成为可能

理解这些概念对于编写灵活、可扩展的C程序至关重要，特别是在系统编程、嵌入式开发和框架设计中。通过合理使用这些技术，可以创建出高度模块化、易于扩展的软件架构。