C语言函数与指针深度解析：从基础转换到高级应用

结果与目标

理解并掌握C语言中函数与指针相互转换的底层机制，能够灵活运用函数指针进行地址间接调用、多态逻辑分发（数组）以及复杂函数签名的读写。

准备条件

1. 编译器环境：支持C89/C99标准的C编译器（如GCC）。
2. 基础知识：熟悉基本数据类型指针、printf输出格式化及基本的内存布局概念。

第1步：验证函数的指针属性

目的：证明C语言中函数名等同于指向该函数的指针，且多次解引用行为一致。

原理：在表达式中，函数名会经历“function-to-pointer”退化，自动转换为指向该函数的指针类型。对指针取地址或解引用最终都回归到相同的函数入口点。

#include <stdio.h>

void fun()
{
}

int main(void)
{
    // 输出三个值，结果通常相同（即函数地址）
    printf("%p %p %p\n", &fun, fun, *fun);
    return 0;
}

注意：*fun、**fun等多重解引用在多数实现中与直接访问函数名效果一致，因为函数指针解引用后仍会被隐式转换回指针。

第2步：通过地址调用函数

目的：演示如何将整数类型的变量视为函数地址，并通过强制类型转换进行调用。这在嵌入式开发或动态链接场景中常见。

操作：

#include <stdio.h>

void f(int i)
{
    printf("i = %d\n", i);
}

int main(void)
{
    unsigned long add;
    // 将函数指针转换为整数地址存储
    add = (unsigned long)f;
    
    // 方法1：先将地址强转为函数指针，再调用
    ((void (*)(int))add)(10);
    
    // 方法2：先解引用获取函数（再次隐式转指针），再调用
    (*(void (*)(int))add)(20);
    
    return 0;
}

完成状态：程序正确输出 i = 10 和 i = 20。这展示了如何通过中间媒介（如配置文件读出的地址或硬件寄存器映射）间接执行代码。

第3步：使用函数指针数组实现逻辑路由

目的：定义一个包含多个函数指针的数组，根据索引动态选择不同的函数执行，减少冗长的if-else或switch结构。

步骤：

1. 定义函数：创建签名相同的函数，如 max, min, sum。
2. 声明数组：使用 int (*p[3])(int, int) 语法声明数组。
3. 初始化与调用：将函数名赋给数组元素并调用。

#include <stdio.h>

int max(int v1, int v2) { return (v1 > v2 ? v1 : v2); }
int min(int v1, int v2) { return (v1 < v2 ? v1 : v2); }
int sum(int v1, int v2) { return (v1 + v2); }

int main(void)
{
    // 声明包含3个函数指针的数组
    int (*p[3])(int, int);
    p[0] = max;
    p[1] = min;
    p[2] = sum;

    // 通过数组索引动态调用
    printf("p[0] = %d\n", (p[0])(3, 5)); // 输出 5
    printf("p[1] = %d\n", (p[1])(4, 6)); // 输出 4
    printf("p[2] = %d\n", (p[2])(1, 2)); // 输出 3
    
    return 0;
}

第4步：函数返回指向数组的指针

目的：学习如何编写返回“指向数组的指针”的函数，解决局部数组无法直接返回的问题。

关键语法：int (*func())[10] 表示函数返回一个指向包含10个整数的数组的指针。

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

// 函数返回指向拥有10个int元素的数组的指针
int (*p())[10]
{
    int (*m)[10]; // m是指向数组的指针
    int i;
    
    // 动态分配内存，因为栈上定义的局部数组不能安全返回
    m = (int (*)[10])malloc(10 * sizeof(int));
    if (m == NULL) {
        printf("malloc error\n");
        exit(1);
    }
    
    for (i = 0; i < 10; i++)
        *(*m + i) = i + 1; // 赋值 1 到 10
        
    return m;
}

int main(void)
{
    int (*a)[10];
    int i;
    
    a = p(); // 获取返回的指针
    for (i = 0; i < 10; i++)
        printf("%d ", *(*a + i));
    printf("\ndone\n");
    
    // 实际项目中应在此处 free(a);
    return 0;
}

风险提示：若不在调用方释放内存，将导致内存泄漏。

第5步：理解返回函数指针的函数（以signal为例）

目的：解析复杂的函数指针声明，理解为何某些API需要返回函数指针。

经典案例：POSIX标准中的 signal 函数原型：

void (*signal (int signo, void (*func)(int)))(int);

拆解分析：

• signal 是一个函数。
• 它接受两个参数：int signo 和一个函数指针 void (*func)(int)。
• 它的返回值也是一个函数指针：void (*)(int)。

应用场景：保存旧的信号处理程序，以便后续恢复。例如：

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

void sig_fun2(int signo) {
    printf("in sig_fun2:%d\n", signo);
}

void sig_fun1(int signo) {
    printf("in sig_fun1:%d\n", signo);
}

int main(void)
{
    unsigned long i;
    // 安装sig_fun1，并保存之前的处理程序
    if (signal(SIGUSR1, sig_fun1) == SIG_ERR) {
        printf("signal fun1 error\n");
        exit(1);
    }

    // 临时更换为sig_fun2，并立即调用其返回值（原处理程序或空）
    // 这里主要演示语法：(signal(...))(...) 表示用signal的返回值作为函数指针调用
    (signal(SIGUSR1, sig_fun2))(30);

    printf("done\n");
    return 0;
}

第6步：将函数指针作为参数传递

目的：实现通用的算法或工具函数，使其行为由调用者决定（回调模式）。

操作：定义一个辅助函数，接收比较或计算函数指针。

#include <stdio.h>

// 假设前面已定义 max, min, sum

// call 是函数指针参数
int fun(int a, int b, int (*call)(int, int))
{
    return call(a, b);
}

int main(void)
{
    printf("max=%d\n", fun(1, 2, max)); // 利用传入的max函数
    printf("min=%d\n", fun(3, 4, min)); // 利用传入的min函数
    printf("sum=%d\n", fun(5, 6, sum)); // 利用传入的sum函数
    
    return 0;
}

简要总结

函数与指针的结合是C语言强大灵活性的核心来源。从简单的地址转换调用，到利用数组实现策略模式的切换，再到处理复杂的信号处理和回调函数，掌握这些知识点对于编写高效、模块化的C代码至关重要。特别注意动态内存管理在返回数组指针时的必要性，以及正确使用括号控制优先级来解读复杂声明。

以上就是C语言中函数与指针应用的详细内容，更多关于C语言指针教程的资料请关注本站其它相关文章！