C语言指针进阶：函数指针与回调机制深度解析

一、指针进阶：函数指针与回调机制深度解析

1.1 学习目标与重点

💡 掌握函数指针的定义、声明与使用方法，理解其在内存中的存储本质；
💡 精通回调函数的设计思想、实现流程及应用场景，能够独立编写带回调机制的模块化代码；
💡 区分函数指针数组与指向函数指针的指针，解决复杂场景下的多函数调度问题；
💡 结合实际项目案例，体会指针进阶特性在代码复用、解耦及扩展中的核心价值。

1.2 函数指针的本质与基础用法

在C语言中，函数作为一段可执行代码，其在内存中同样占据特定的存储空间，而函数名本质上就是该存储空间的起始地址（入口地址）。函数指针，就是专门用于存储函数入口地址的指针变量，通过它可以间接调用对应的函数。

1.2.1 函数指针的定义与声明

函数指针的声明格式需明确函数的返回值类型、参数列表，其核心语法为：

返回值类型 (*指针变量名)(参数类型列表);

⚠️ 注意：括号 (*指针变量名) 不可省略，否则会被解析为“返回值为指针的函数”（函数指针与指针函数的关键区别）。

示例1：声明指向不同类型函数的指针

#include <stdio.h>

// 1. 无返回值、无参数的函数
void printHello() {
    printf("Hello, Function Pointer!\n");
}

// 2. 有返回值、有参数的函数
int add(int a, int b) {
    return a + b;
}

// 3. 返回值为指针、参数为int的函数（指针函数，用于对比）
int* getArray(int size) {
    static int arr[100]; // 静态数组，避免栈空间释放
    for (int i = 0; i < size; i++) {
        arr[i] = i * 2;
    }
    return arr;
}

int main() {
    // 声明函数指针并赋值（函数名直接作为地址）
    void (*pFunc1)() = printHello; // 指向无参无返回值函数
    int (*pFunc2)(int, int) = add; // 指向两个int参数、返回int的函数
    int* (*pFunc3)(int) = getArray; // 指向指针函数的函数指针

    // 验证：函数名与函数指针的地址是否一致
    printf("printHello的地址：%p\n", printHello);
    printf("pFunc1的地址：%p\n", pFunc1);
    printf("add的地址：%p\n", add);
    printf("pFunc2的地址：%p\n", pFunc2);

    return 0;
}

运行结果：

printHello的地址：0x400526
pFunc1的地址：0x400526
add的地址：0x400536
pFunc2的地址：0x400536

✅ 结论：函数名直接代表函数的入口地址，函数指针赋值时无需加 &（加 & 也合法，效果一致）。

1.2.2 函数指针的调用方式

通过函数指针调用函数有两种等价写法，推荐使用第一种（更直观）：

// 方式1：指针变量名(参数列表)
(*pFunc2)(3, 5); 
// 方式2：指针变量名(参数列表)（编译器自动解析，与方式1等价）
pFunc2(3, 5);

示例2：通过函数指针调用函数

#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) {
    if (b == 0) {
        printf("⚠️  除数不能为0！\n");
        return 0;
    }
    return a / b;
}

int main() {
    int (*calcFunc)(int, int); // 声明函数指针
    int x = 10, y = 5;

    // 调用加法
    calcFunc = add;
    printf("%d + %d = %d\n", x, y, calcFunc(x, y)); // 等价于 (*calcFunc)(x,y)

    // 调用减法
    calcFunc = subtract;
    printf("%d - %d = %d\n", x, y, calcFunc(x, y));

    // 调用乘法
    calcFunc = multiply;
    printf("%d * %d = %d\n", x, y, calcFunc(x, y));

    // 调用除法
    calcFunc = divide;
    printf("%d / %d = %d\n", x, y, calcFunc(x, y));

    // 测试除数为0的情况
    y = 0;
    printf("%d / %d = %d\n", x, y, calcFunc(x, y));

    return 0;
}

运行结果：

10 + 5 = 15
10 - 5 = 5
10 * 5 = 50
10 / 5 = 2
⚠️  除数不能为0！
10 / 0 = 0

💡 技巧：函数指针的核心价值在于“动态切换函数”——无需修改调用逻辑，只需改变指针指向的函数地址，即可实现不同功能的调用，为后续回调机制奠定基础。

1.2.3 函数指针的应用场景1：简化多函数调度

当需要频繁调用多个参数列表、返回值类型相同的函数时，函数指针可替代大量重复代码，提升代码简洁性。

场景：实现一个简易计算器，支持加减乘除、取模运算

#include <stdio.h>

// 定义运算函数
int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }
int mul(int a, int b) { return a * b; }
int div(int a, int b) { return b ? a / b : -1; } // 简化错误处理
int mod(int a, int b) { return b ? a % b : -1; }

// 运算类型枚举
typedef enum {
    ADD, SUB, MUL, DIV, MOD, EXIT
} OpType;

int main() {
    // 函数指针数组：存储所有运算函数的地址（参数列表、返回值必须一致）
    int (*opFuncs[])(int, int) = {add, sub, mul, div, mod};
    
    int a, b, op;
    while (1) {
        // 显示菜单
        printf("\n===== 简易计算器 =====\n");
        printf("0. 加法\n1. 减法\n2. 乘法\n3. 除法\n4. 取模\n5. 退出\n");
        printf("请选择运算类型：");
        scanf("%d", &op);

        if (op == EXIT) {
            printf("✅ 退出计算器！\n");
            break;
        }

        if (op < 0 || op >= EXIT) {
            printf("⚠️  无效的运算类型！\n");
            continue;
        }

        printf("请输入两个整数（用空格分隔）：");
        scanf("%d %d", &a, &b);

        // 通过函数指针数组调用对应函数
        int result = opFuncs[op](a, b);
        if (result == -1 && (op == DIV || op == MOD)) {
            printf("⚠️  除数不能为0！\n");
        } else {
            printf("运算结果：%d\n", result);
        }
    }

    return 0;
}

运行结果：

===== 简易计算器 =====
0. 加法
1. 减法
2. 乘法
3. 除法
4. 取模
5. 退出
请选择运算类型：0
请输入两个整数（用空格分隔）：12 34
运算结果：46

===== 简易计算器 =====
0. 加法
1. 减法
2. 乘法
3. 除法
4. 取模
5. 退出
请选择运算类型：3
请输入两个整数（用空格分隔）：50 0
⚠️  除数不能为0！

===== 简易计算器 =====
0. 加法
1. 减法
2. 乘法
3. 除法
4. 取模
5. 退出
请选择运算类型：5
✅ 退出计算器！

✅ 结论：函数指针数组 opFuncs 将所有运算函数统一管理，通过枚举值作为索引直接调用，避免了冗长的 if-else 或 switch 分支，后续新增运算（如平方、开方）只需添加函数并更新数组，扩展性极强。

1.3 回调函数：解耦与复用的核心机制

1.3.1 回调函数的定义与设计思想

回调函数（Callback Function）是指通过函数指针传递给另一个函数，并在该函数内部被调用的函数。简单来说：函数A将函数B的指针作为参数传入，函数A执行过程中调用函数B，此时函数B就是回调函数。

💡 核心思想：“主函数”（如函数A）定义通用逻辑，“回调函数”（如函数B）定义具体细节，通过函数指针实现“通用逻辑与具体细节的解耦”——主函数无需修改，只需更换回调函数，即可实现不同功能。

1.3.2 回调函数的实现流程

回调函数的实现分为3步：
① 定义回调函数（具体功能实现）；
② 定义“接收回调的函数”（主函数，参数包含函数指针）；
③ 调用“接收回调的函数”，传入回调函数的地址。

示例3：实现一个通用排序函数，支持升序、降序回调

#include <stdio.h>

// 步骤1：定义回调函数（比较规则）
// 升序比较：a > b 返回1，否则返回0
int compareAsc(int a, int b) {
    return a > b ? 1 : 0;
}

// 降序比较：a < b 返回1，否则返回0
int compareDesc(int a, int b) {
    return a < b ? 1 : 0;
}

// 步骤2：定义接收回调的函数（通用排序逻辑：冒泡排序）
// 参数1：待排序数组；参数2：数组长度；参数3：比较规则的函数指针
void bubbleSort(int arr[], int len, int (*compare)(int, int)) {
    for (int i = 0; i < len - 1; i++) {
        for (int j = 0; j < len - 1 - i; j++) {
            // 步骤3：在主函数内部调用回调函数，决定是否交换
            if (compare(arr[j], arr[j + 1])) {
                // 交换元素
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

// 辅助函数：打印数组
void printArray(int arr[], int len) {
    for (int i = 0; i < len; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

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

    printf("原始数组：");
    printArray(arr, len);

    // 传入升序回调函数
    bubbleSort(arr, len, compareAsc);
    printf("升序排序后：");
    printArray(arr, len);

    // 重新初始化数组
    int arr2[] = {5, 2, 9, 1, 5, 6};
    // 传入降序回调函数
    bubbleSort(arr2, len, compareDesc);
    printf("降序排序后：");
    printArray(arr2, len);

    return 0;
}

运行结果：

原始数组：5 2 9 1 5 6 
升序排序后：1 2 5 5 6 9 
降序排序后：9 6 5 5 2 1 

⚠️ 注意：回调函数的参数列表、返回值类型必须与接收它的函数指针参数完全匹配，否则会导致编译错误或运行时异常。

1.3.3 回调函数的应用场景2：事件驱动编程

在实际开发中，回调函数广泛用于事件处理（如按钮点击、定时器触发、网络请求响应等）。以“定时器回调”为例，定时器函数负责计时逻辑，回调函数负责计时结束后的具体操作。

示例4：模拟定时器回调机制

#include <stdio.h>
#include <unistd.h> // 包含sleep函数（Linux系统）

// 回调函数1：定时结束后打印提示信息
void timerCallback1() {
    printf("⏰ 定时器1触发：任务A执行完成！\n");
}

// 回调函数2：定时结束后计算并打印结果
void timerCallback2() {
    int sum = 0;
    for (int i = 1; i <= 100; i++) {
        sum += i;
    }
    printf("⏰ 定时器2触发：1-100的和为%d\n", sum);
}

// 定时器函数（接收回调函数指针，延迟指定秒数后调用）
void startTimer(int delaySec, void (*callback)()) {
    printf("定时器启动，延迟%d秒后执行回调函数...\n", delaySec);
    sleep(delaySec); // 延迟delaySec秒（Linux）；Windows使用Sleep(delaySec*1000)
    callback(); // 调用回调函数
}

int main() {
    // 启动定时器1：延迟2秒，执行回调1
    startTimer(2, timerCallback1);

    // 启动定时器2：延迟3秒，执行回调2
    startTimer(3, timerCallback2);

    return 0;
}

运行结果：

定时器启动，延迟2秒后执行回调函数...
⏰ 定时器1触发：任务A执行完成！
定时器启动，延迟3秒后执行回调函数...
⏰ 定时器2触发：1-100的和为5050

💡 技巧：在嵌入式开发、GUI编程中，回调函数是事件驱动的核心。例如，在Qt中，按钮的点击事件就是通过回调函数（槽函数）实现的；在Linux内核中，中断处理函数本质上也是一种回调函数。

1.3.4 带参数的回调函数

实际场景中，回调函数往往需要接收参数以实现更灵活的功能。此时，“接收回调的函数”需要同时传递回调函数的参数（通常通过void*类型实现通用参数传递）。

示例5：带参数的回调函数——数组过滤

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

// 回调函数1：过滤偶数（参数：数组元素，返回1表示保留，0表示过滤）
int filterEven(int num, void* args) {
    return num % 2 == 0 ? 1 : 0;
}

// 回调函数2：过滤长度大于指定值的字符串（参数：字符串，args：指定长度）
int filterStrLen(char* str, void* args) {
    int minLen = *(int*)args; // 将void*强制转换为int*，再取值
    return strlen(str) > minLen ? 1 : 0;
}

// 通用过滤函数（支持int数组和字符串数组，通过回调函数定义过滤规则）
// 参数：data-数据数组；len-元素个数；elemSize-单个元素大小；
//      filter-回调函数；args-回调函数的额外参数；result-输出结果；resultLen-结果长度
void filterData(void* data, int len, int elemSize,
               int (*filter)(void*, void*), void* args,
               void* result, int* resultLen) {
    *resultLen = 0;
    char* pData = (char*)data; // 以字节为单位遍历数组

    for (int i = 0; i < len; i++) {
        void* elem = pData + i * elemSize; // 当前元素的地址
        // 调用回调函数，判断是否保留该元素
        if (filter(elem, args)) {
            // 将元素复制到结果数组
            memcpy((char*)result + (*resultLen) * elemSize, elem, elemSize);
            (*resultLen)++;
        }
    }
}

int main() {
    // 场景1：过滤int数组中的偶数
    int intArr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int intLen = sizeof(intArr) / sizeof(intArr[0]);
    int intResult[10];
    int intResLen;

    filterData(intArr, intLen, sizeof(int), 
               (int (*)(void*, void*))filterEven, // 强制类型转换（回调函数参数适配）
               NULL, intResult, &intResLen);

    printf("过滤后的偶数：");
    for (int i = 0; i < intResLen; i++) {
        printf("%d ", intResult[i]);
    }
    printf("\n");

    // 场景2：过滤字符串数组中长度大于3的字符串
    char* strArr[] = {"a", "ab", "abc", "abcd", "abcde", "abcdef"};
    int strLen = sizeof(strArr) / sizeof(strArr[0]);
    char* strResult[10];
    int strResLen;
    int minLen = 3; // 回调函数的额外参数

    filterData(strArr, strLen, sizeof(char*),
               (int (*)(void*, void*))filterStrLen,
               &minLen, strResult, &strResLen);

    printf("长度大于3的字符串：");
    for (int i = 0; i < strResLen; i++) {
        printf("%s ", strResult[i]);
    }
    printf("\n");

    return 0;
}

运行结果：

过滤后的偶数：2 4 6 8 10 
长度大于3的字符串：abcd abcde abcdef 

✅ 结论：通过void*类型的参数，回调函数可以接收任意类型的额外数据，使通用函数（如filterData）能够适配不同的数据类型和过滤规则，极大提升了代码的复用性和灵活性。

1.4 函数指针的高级用法：指向函数指针的指针

当需要动态修改函数指针的指向（如在函数内部修改外部函数指针的值），或需要传递函数指针的地址时，就需要使用“指向函数指针的指针”（即二级函数指针）。

1.4.1 二级函数指针的定义与声明

二级函数指针的声明格式为：

返回值类型 (**二级指针变量名)(参数类型列表);

其本质是：一个指针变量，指向的是“函数指针变量”的地址。

示例6：二级函数指针的基本使用

#include <stdio.h>

void funcA() {
    printf("执行函数A\n");
}

void funcB() {
    printf("执行函数B\n");
}

// 函数：通过二级函数指针修改外部函数指针的指向
void changeFuncPtr(void (**pFunc)(), void (*newFunc)()) {
    *pFunc = newFunc; // 解引用二级指针，修改原始函数指针的值
}

int main() {
    void (*pFunc)() = funcA; // 一级函数指针，指向funcA
    void (**ppFunc)() = &pFunc; // 二级函数指针，指向pFunc

    printf("初始调用：");
    pFunc(); // 执行funcA

    // 通过二级指针直接调用函数（等价于 (*ppFunc)() 或 pFunc()）
    printf("通过二级指针调用：");
    (**ppFunc)();

    // 调用函数修改函数指针的指向
    changeFuncPtr(&pFunc, funcB);
    printf("修改后调用：");
    pFunc(); // 执行funcB

    // 通过二级指针修改函数指针指向
    *ppFunc = funcA;
    printf("通过二级指针修改后调用：");
    pFunc(); // 执行funcA

    return 0;
}

运行结果：

初始调用：执行函数A
通过二级指针调用：执行函数A
修改后调用：执行函数B
通过二级指针修改后调用：执行函数A

⚠️ 注意：二级函数指针的解引用需要两层*，**ppFunc 等价于 *pFunc（即函数地址），因此 (**ppFunc)() 等价于 pFunc()。

1.4.2 二级函数指针的应用场景3：动态注册函数

在框架开发中，常通过二级函数指针实现“函数注册机制”——外部模块可以将自己的函数注册到框架中，框架通过函数指针统一调用，实现模块间的解耦。

示例7：实现一个简单的插件注册框架

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

// 插件函数类型定义（简化函数指针声明）
typedef void (*PluginFunc)(const char* msg);

// 框架中的函数指针（用于存储注册的插件函数）
PluginFunc g_pluginFunc = NULL;

// 注册插件函数（接收二级函数指针，将外部插件函数注册到框架）
void registerPlugin(PluginFunc (*pPluginFunc)(const char*), PluginFunc newPlugin) {
    *pPluginFunc = newPlugin;
    printf("✅ 插件注册成功！\n");
}

// 框架核心逻辑：调用注册的插件函数
void frameworkRun(const char* msg) {
    if (g_pluginFunc != NULL) {
        printf("框架触发插件执行：");
        g_pluginFunc(msg);
    } else {
        printf("⚠️  未注册任何插件！\n");
    }
}

// 插件1：日志插件
void logPlugin(const char* msg) {
    printf("[日志插件] %s\n", msg);
}

// 插件2：告警插件
void alertPlugin(const char* msg) {
    printf("[告警插件] %s\n", msg);
}

int main() {
    // 未注册插件时运行框架
    frameworkRun("系统启动");

    // 注册日志插件
    registerPlugin(&g_pluginFunc, logPlugin);
    frameworkRun("用户登录成功");

    // 切换注册告警插件
    registerPlugin(&g_pluginFunc, alertPlugin);
    frameworkRun("磁盘空间不足！");

    return 0;
}

运行结果：

⚠️  未注册任何插件！
✅ 插件注册成功！
框架触发插件执行：[日志插件] 用户登录成功
✅ 插件注册成功！
框架触发插件执行：[告警插件] 磁盘空间不足！

💡 技巧：typedef 可以简化函数指针的声明，如 typedef void (*PluginFunc)(const char*) 定义了一个名为 PluginFunc 的函数指针类型，后续声明时直接使用 PluginFunc 即可，避免重复编写复杂的函数指针格式。

1.5 实际项目案例：基于回调机制的数组处理库

1.5.1 案例需求

实现一个通用的数组处理库，支持以下功能：

1. 数组遍历（回调函数处理每个元素）；
2. 数组映射（通过回调函数将元素转换为新值）；
3. 数组折叠（通过回调函数累加元素，得到一个结果）；
4. 支持int、float、char三种数据类型。

1.5.2 案例实现

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

// ==================== 类型定义与工具函数 ====================
// 数据类型枚举
typedef enum {
    TYPE_INT, TYPE_FLOAT, TYPE_CHAR
} DataType;

// 遍历回调函数类型：参数为元素地址、元素索引、额外参数
typedef void (*TraverseCallback)(void*, int, void*);

// 映射回调函数类型：参数为元素地址、额外参数，返回新元素地址
typedef void (*MapCallback)(void*, void*, void*);

// 折叠回调函数类型：参数为累加结果地址、当前元素地址、额外参数
typedef void (*ReduceCallback)(void*, void*, void*);

// 获取数据类型大小
int getTypeSize(DataType type) {
    switch (type) {
        case TYPE_INT: return sizeof(int);
        case TYPE_FLOAT: return sizeof(float);
        case TYPE_CHAR: return sizeof(char);
        default: return 0;
    }
}

// ==================== 数组遍历函数 ====================
void arrayTraverse(void* arr, int len, DataType type,
                  TraverseCallback traverse, void* args) {
    int elemSize = getTypeSize(type);
    char* pArr = (char*)arr;

    for (int i = 0; i < len; i++) {
        void* elem = pArr + i * elemSize;
        traverse(elem, i, args); // 回调处理每个元素
    }
}

// ==================== 数组映射函数 ====================
void arrayMap(void* srcArr, void* destArr, int len, DataType type,
             MapCallback map, void* args) {
    int elemSize = getTypeSize(type);
    char* pSrc = (char*)srcArr;
    char* pDest = (char*)destArr;

    for (int i = 0; i < len; i++) {
        void* srcElem = pSrc + i * elemSize;
        void* destElem = pDest + i * elemSize;
        map(srcElem, destElem, args); // 回调转换元素
    }
}

// ==================== 数组折叠函数 ====================
void arrayReduce(void* arr, int len, DataType type,
                ReduceCallback reduce, void* result, void* args) {
    int elemSize = getTypeSize(type);
    char* pArr = (char*)arr;

    // 初始化结果为第一个元素
    memcpy(result, pArr, elemSize);

    for (int i = 1; i < len; i++) {
        void* elem = pArr + i * elemSize;
        reduce(result, elem, args); // 回调累加元素
    }
}

// ==================== 回调函数实现（int类型） ====================
// int数组遍历回调：打印元素
void traverseInt(void* elem, int idx, void* args) {
    printf("索引%d：%d\n", idx, *(int*)elem);
}

// int数组映射回调：元素乘以2
void mapIntDouble(void* srcElem, void* destElem, void* args) {
    *(int*)destElem = *(int*)srcElem * 2;
}

// int数组折叠回调：元素求和
void reduceIntSum(void* result, void* elem, void* args) {
    *(int*)result += *(int*)elem;
}

// ==================== 回调函数实现（float类型） ====================
// float数组遍历回调：打印元素
void traverseFloat(void* elem, int idx, void* args) {
    printf("索引%d：%.2f\n", idx, *(float*)elem);
}

// float数组映射回调：元素加1.5
void mapFloatAdd(void* srcElem, void* destElem, void* args) {
    *(float*)destElem = *(float*)srcElem + 1.5f;
}

// float数组折叠回调：元素求平均（args为长度）
void reduceFloatAvg(void* result, void* elem, void* args) {
    static int count = 1; // 统计累加次数（从1开始，因为result已初始化）
    *(float*)result += *(float*)elem;
    if (count == *(int*)args) {
        *(float*)result /= *(int*)args; // 最后一次累加后求平均
        count = 1; // 重置计数器，支持多次调用
    } else {
        count++;
    }
}

// ==================== 主函数测试 ====================
int main() {
    // 测试1：int数组处理
    printf("===== 测试int数组处理 =====\n");
    int intArr[] = {1, 2, 3, 4, 5};
    int intLen = sizeof(intArr) / sizeof(intArr[0]);

    // 遍历
    printf("int数组遍历：\n");
    arrayTraverse(intArr, intLen, TYPE_INT, traverseInt, NULL);

    // 映射（元素乘以2）
    int intMapResult[5];
    arrayMap(intArr, intMapResult, intLen, TYPE_INT, mapIntDouble, NULL);
    printf("int数组映射（乘以2）：\n");
    arrayTraverse(intMapResult, intLen, TYPE_INT, traverseInt, NULL);

    // 折叠（求和）
    int intSum;
    arrayReduce(intArr, intLen, TYPE_INT, reduceIntSum, &intSum, NULL);
    printf("int数组求和结果：%d\n", intSum);

    // 测试2：float数组处理
    printf("\n===== 测试float数组处理 =====\n");
    float floatArr[] = {1.1f, 2.2f, 3.3f, 4.4f, 5.5f};
    int floatLen = sizeof(floatArr) / sizeof(floatArr[0]);

    // 遍历
    printf("float数组遍历：\n");
    arrayTraverse(floatArr, floatLen, TYPE_FLOAT, traverseFloat, NULL);

    // 映射（元素加1.5）
    float floatMapResult[5];
    arrayMap(floatArr, floatMapResult, floatLen, TYPE_FLOAT, mapFloatAdd, NULL);
    printf("float数组映射（加1.5）：\n");
    arrayTraverse(floatMapResult, floatLen, TYPE_FLOAT, traverseFloat, NULL);

    // 折叠（求平均）
    float floatAvg;
    arrayReduce(floatArr, floatLen, TYPE_FLOAT, reduceFloatAvg, &floatAvg, &floatLen);
    printf("float数组平均结果：%.2f\n", floatAvg);

    return 0;
}

运行结果：

===== 测试int数组处理 =====
int数组遍历：
索引0：1
索引1：2
索引2：3
索引3：4
索引4：5
int数组映射（乘以2）：
索引0：2
索引1：4
索引2：6
索引3：8
索引4：10
int数组求和结果：15

===== 测试float数组处理 =====
float数组遍历：
索引0：1.10
索引1：2.20
索引2：3.30
索引3：4.40
索引4：5.50
float数组映射（加1.5）：
索引0：2.60
索引1：3.70
索引2：4.80
索引3：5.90
索引4：7.00
float数组平均结果：3.30

✅ 案例总结：该数组处理库通过回调机制实现了“通用逻辑与具体数据类型处理的解耦”——核心函数（arrayTraverse、arrayMap、arrayReduce）不依赖具体数据类型，只需为不同类型实现对应的回调函数，即可扩展支持新的数据类型（如char、struct），完全符合“开闭原则”（对扩展开放，对修改关闭）。

1.6 常见问题与避坑指南

1.6.1 函数指针与指针函数的混淆

⚠️ 避坑技巧：通过括号位置区分——(*p) 是函数指针（指针变量），p() 是指针函数（函数声明）。

1.6.2 回调函数的类型不匹配

错误场景：回调函数的参数列表、返回值类型与接收它的函数指针参数不一致。

// 错误示例
void callback(int a) { ... }
// 接收回调的函数期望“无参数、无返回值”的函数指针
void func(void (*cb)()) {
    cb(); // 编译警告：参数不匹配
}
func(callback); // 错误：回调函数类型不匹配

✅ 解决方案：严格保证回调函数的签名（返回值类型+参数列表）与函数指针参数完全一致，必要时通过typedef统一类型定义。

1.6.3 函数指针指向非法地址

错误场景：未初始化函数指针就调用，或指向已释放的函数（如静态函数被销毁）。

// 错误示例
void (*pFunc)();
pFunc(); // 未初始化，指向随机地址，运行时崩溃

✅ 解决方案：

1. 函数指针声明后立即初始化（指向合法函数或NULL）；
2. 调用前检查函数指针是否为NULL，避免空指针调用。

void (*pFunc)() = NULL;
if (pFunc != NULL) {
    pFunc(); // 安全调用
}

1.6.4 void*参数的类型转换错误

错误场景：将void*强制转换为错误的类型，导致内存访问异常。

// 错误示例
void callback(void* args) {
    int num = *(char*)args; // 实际传入的是int*，转换错误
}
int data = 10;
func(callback, &data);

✅ 解决方案：明确void*参数的实际类型，转换时严格匹配，建议在文档中注明回调函数的参数类型要求。

1.7 本章总结

本章深入讲解了C语言指针的进阶特性——函数指针与回调机制，核心要点如下：

1. 函数指针是存储函数入口地址的指针变量，可实现动态函数调用和多函数统一调度；
2. 回调函数通过函数指针传递给主函数，实现“通用逻辑与具体细节的解耦”，是模块化、可扩展代码的核心技术；
3. 函数指针数组适用于多函数批量管理，二级函数指针适用于动态修改函数指针或函数注册场景；
4. 实际开发中，回调函数广泛应用于排序、事件处理、框架设计等场景，能够极大提升代码的复用性和灵活性。

💡 学习建议：函数指针与回调机制是C语言的难点，但也是区分初级程序员与高级程序员的关键。建议多通过实际案例练习（如实现一个带回调的排序库、简易事件框架），深入理解其“解耦”的核心思想，为后续学习Linux内核、嵌入式开发等打下基础。

下一章，我们将学习指针的终极应用——指针与结构体、联合体的结合，以及复杂数据结构（如链表、栈、队列）的实现，进一步提升代码的模块化和高效性。