深入解析C++函数调用的详细步骤：从栈帧到参数传递

1次阅读

共计 2313 个字符，预计需要花费 6 分钟才能阅读完成。

当我们在 C ++ 中调用一个函数时，编译器会在背后做大量工作来确保函数能够正确执行并返回。理解这些底层机制不仅能帮助我们写出更好的代码，还能在遇到问题时快速定位原因。

每个函数调用都会在栈上创建一个独立的栈帧(stack frame)，它像是函数的临时工作区。栈帧包含以下几个关键部分：

函数参数
返回地址（调用结束后应该回到哪里继续执行）
局部变量
保存的寄存器值

用 GCC 编译以下简单示例（使用 -S 选项生成汇编代码）：

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

int main() {int result = add(3, 5);
    return 0;
}

对应的 x86 汇编关键部分：

add:
    push    rbp         ; 保存旧的基址指针
    mov     rbp, rsp    ; 设置新的栈帧基址
    sub     rsp, 16     ; 为局部变量预留空间
    mov     DWORD PTR [rbp-4], edi  ; 存储参数 a
    mov     DWORD PTR [rbp-8], esi  ; 存储参数 b
    mov     edx, DWORD PTR [rbp-4]  ; 读取 a
    mov     eax, DWORD PTR [rbp-8]  ; 读取 b
    add     eax, edx    ; 计算 a +b
    mov     DWORD PTR [rbp-12], eax ; 存储 sum
    mov     eax, DWORD PTR [rbp-12] ; 准备返回值
    leave               ; 恢复栈帧
    ret                 ; 返回

main:
    push    rbp
    mov     rbp, rsp
    mov     esi, 5      ; 第二个参数
    mov     edi, 3      ; 第一个参数
    call    add
    mov     DWORD PTR [rbp-4], eax  ; 存储返回值
    mov     eax, 0
    pop     rbp
    ret

最直接的方式，函数获得参数的副本。对副本的修改不会影响原变量。

void modify(int x) {x = 10;  // 只修改副本}

传递原始变量的别名，所有修改直接影响原变量。

void modify(int &x) {x = 10;  // 修改原始变量}

传递变量的地址，通过解引用操作符 (*) 访问和修改原变量。

void modify(int *x) {*x = 10;  // 通过指针修改原始变量}

在汇编层面，传引用和传指针非常相似，都是传递内存地址。但编译器会确保引用始终有效（不为 nullptr）。

观察这个更复杂的例子：

#include <iostream>

struct Point {
    int x;
    int y;
};

void process(Point p, int &ref, int *ptr) {
    p.x += 10;    // 修改副本
    ref += 20;    // 修改引用
    *ptr += 30;   // 通过指针修改
}

int main() {Point pt = {1, 2};
    int a = 10, b = 20;
    process(pt, a, &b);
    std::cout << "pt.x:" << pt.x 
              << ", a:" << a 
              << ", b:" << b << std::endl;
    return 0;
}

对应的关键汇编指令（x86-64）：

process:
    ; 参数布局:
    ; rdi: Point p (传值，通过寄存器)
    ; rsi: int &ref (传引用，实际是地址)
    ; rdx: int *ptr (传指针)
    mov     eax, edi    ; 获取 p.x
    add     eax, 10     ; p.x += 10
    mov     edi, eax    ; 存回 p.x（但不会影响 main 中的 pt）mov     eax, DWORD PTR [rsi]  ; 通过引用获取值
    add     eax, 20               ; ref += 20
    mov     DWORD PTR [rsi], eax  ; 存回原变量

    mov     eax, DWORD PTR [rdx]  ; 通过指针获取值
    add     eax, 30               ; *ptr += 30
    mov     DWORD PTR [rdx], eax  ; 存回原变量
    ret

main:
    ; ... 初始化 pt, a, b ...
    lea     rdx, [rbp-12]  ; &b
    lea     rsi, [rbp-8]   ; &a (引用)
    mov     edi, DWORD PTR [rbp-16]  ; pt.x
    mov     esi, DWORD PTR [rbp-12]  ; pt.y
    call    process
    ; ... 输出结果 ...

递归调用过深或局部变量过大可能导致栈空间耗尽。解决方案：

将大型数据改为动态分配（堆内存）
限制递归深度或改为迭代实现

不同编译器或语言可能使用不同的调用约定（如__cdecl、__stdcall）。混合使用时会导致栈不平衡。解决方案：

明确指定调用约定
在跨语言调用时使用统一接口

编译器可能会优化掉不必要的拷贝构造：

std::string createString() {
    std::string s = "hello";
    return s;  // 可能直接构造在调用者的内存中，避免拷贝
}

使用 GDB 查看栈帧和寄存器：

编译时添加 -g 选项
启动 GDB：gdb ./your_program
常用命令：

break main      # 在 main 函数设置断点
run            # 运行程序
info frame     # 查看当前栈帧信息
info registers # 查看寄存器值
x/10x $sp      # 查看栈内存
stepi          # 单步执行汇编指令

当函数参数包含复杂对象（如大型结构体或类）时，传值方式会导致整个对象被拷贝到栈上，产生显著开销。这种情况下应该：