17、函数指针的底层原理：汇编层面看函数调用与指针跳转

说实话，很多C语言开发者用函数指针用了好几年，但真要问一句「函数指针跳转和直接函数调用，在底层到底有什么区别？」——能答上来的人不多。

我当年刚入行时也是这样。直到有一次在ARM Cortex-M3上做Bootloader，发现函数指针跳转时程序莫名其妙跑飞了。折腾了两天，最后反汇编一看，才恍然大悟。嗯，今天我们就从汇编层面，把这件事彻底讲透。

17.1 普通函数调用：编译器的「固定套路」

先看一个最简单的例子：

void func(int a, int b) {
    int c = a + b;
}

int main() {
    func(3, 4);
    return 0;
}

编译成ARM汇编（简化版）后，大概是这样的：

main:
    MOV   R0, #3        ; 第一个参数放入R0
    MOV   R1, #4        ; 第二个参数放入R1
    BL    func          ; 跳转到func，同时保存返回地址到LR
    MOV   R0, #0        ; return 0
    BX    LR            ; 返回

func:
    ADD   R2, R0, R1    ; c = a + b
    BX    LR            ; 返回

注意看 BL func 这条指令。它做了两件事：

• 把当前PC+4（下一条指令地址）存入LR寄存器
• 把PC直接改成func函数的地址

这里的关键是：func的地址在编译链接时就确定了。链接器会把所有函数符号解析成绝对地址或相对偏移。所以 BL 指令里直接编码了一个偏移量，跳转是「硬编码」的。

17.2 函数指针调用：间接跳转的「真面目」

现在换成函数指针：

void func(int a, int b) {
    int c = a + b;
}

int main() {
    void (*fp)(int, int) = func;
    fp(3, 4);
    return 0;
}

反汇编后：

main:
    LDR   R0, =func     ; 把func的地址加载到R0
    STR   R0, [SP]      ; 存入栈上（fp变量）
    MOV   R0, #3
    MOV   R1, #4
    LDR   R3, [SP]      ; 从栈上取出fp的值
    BLX   R3            ; 跳转到R3指向的地址
    MOV   R0, #0
    BX    LR

看到了吗？这里用的是 BLX R3，而不是 BL func。区别在于：

• BL func：目标地址编码在指令里，CPU直接取指执行
• BLX R3：目标地址来自寄存器，CPU先读寄存器，再跳转

说白了，函数指针调用就是多了一层「间接寻址」。这个间接层，给了你运行时动态切换函数的能力——但也带来了额外的开销和风险。

17.3 函数指针的「跳转表」本质

你想想看，函数指针数组是什么？本质上就是一张跳转表。这张表里存的全是函数的入口地址。

我曾经在一个通信协议栈里，用函数指针数组实现状态机：

typedef void (*state_handler_t)(void);

state_handler_t state_table[] = {
    state_idle,
    state_connect,
    state_send,
    state_recv,
    state_close
};

void run_state_machine(int state) {
    if (state < 5 && state_table[state]) {
        state_table[state]();  // 间接跳转
    }
}

反汇编后，state_table[state]() 会变成：

    LDR   R0, =state_table   ; 获取跳转表基地址
    LSL   R1, R0, #2         ; state * 4（每个指针4字节）
    LDR   R2, [R0, R1]       ; 从表中取出函数地址
    BLX   R2                 ; 间接跳转

这就是典型的「查表跳转」。C语言里的虚函数表（vtable），底层也是这个原理。

17.4 调用约定与栈帧：函数指针也不例外

不管是直接调用还是通过指针调用，参数传递和栈帧管理完全一样。因为调用约定（Calling Convention）是函数层面的约定，跟调用方式无关。

以ARM的ATPCS（ARM-Thumb Procedure Call Standard）为例：

• 参数1-4：R0-R3
• 返回值：R0
• 被调用者保存：R4-R11
• 调用者保存：R0-R3, LR

函数指针调用时，编译器照样会把参数塞进R0-R3，然后执行BLX。被调函数根本不知道自己是「被指针调」还是「被名字调」——它只管从R0-R3拿参数，算完结果放R0，然后BX LR返回。

所以从被调函数的角度看，两者完全等价。区别只在调用者这一侧：多了一次从内存或寄存器读取目标地址的操作。

17.5 性能开销到底有多大？

我直接给一组实测数据（ARM Cortex-M4, 168MHz, 开启-O2优化）：

调用方式	单次调用耗时（周期）	额外开销
直接调用（BL）	约3-4周期	无
函数指针调用（BLX Rn）	约5-7周期	多2-3周期
虚函数调用（查表+BLX）	约7-10周期	多4-6周期

你看，单次调用差不了太多。但如果每秒调用几百万次，这个差距就不可忽视了。我在做电机FOC控制算法时，电流环的PWM中断里坚决不用函数指针——因为每个微秒都很宝贵。

17.6 本章知识体系

下面这张图帮你梳理了函数指针底层的核心逻辑：

这张图把两种调用方式的差异摆得很清楚了。左边是直接调用，右边是函数指针调用。你写C代码时只差了一个星号，但底层汇编差了整整一条LDR指令。这就是「抽象」的代价——也是「灵活」的代价。

---