32、栈的使用

原创于 2025-06-20 10:27:15 发布 · 47 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#栈 # 函数调用 # 栈帧

深入浅出编译原理与Pascal实践专栏收录该内容

40 篇文章 ¥499.90

订阅专栏¥69.90

会员秒杀 ¥9.9 重磅福利

超级会员免费看

栈的使用

1 栈的基本概念

栈（Stack）是一种后进先出（LIFO, Last In First Out）的数据结构，广泛应用于计算机科学的各个领域，特别是在编译器设计中。栈的主要特点是元素按照特定顺序压入（push）和弹出（pop）。栈在编译器中的主要作用包括支持函数调用、参数传递、局部变量存储等。

1.1 栈的特点

后进先出 ：最后压入栈的元素最先弹出。
动态分配 ：栈的大小可以根据需要动态调整。
高效操作 ：栈的插入和删除操作的时间复杂度为O(1)。

1.2 栈在编译器中的作用

栈在编译器中的主要作用如下：
- 函数调用 ：保存返回地址、参数和局部变量。
- 表达式求值 ：用于表达式求值时的操作数和运算符的临时存储。
- 错误处理 ：用于异常处理和错误恢复。

2 栈在编译器中的应用

2.1 函数调用

在编译器中，函数调用是一个非常重要的操作。每当调用一个函数时，编译器需要为该函数创建一个新的栈帧（Stack Frame），用于存储该函数的局部变量、参数和返回地址。

2.1.1 栈帧结构

栈帧是函数调用时创建的局部存储区域，其结构如下表所示：

字段	描述
返回地址	函数返回后继续执行的地址
参数	传递给函数的参数
局部变量	函数内部声明的局部变量
保存的寄存器	函数调用前保存的寄存器状态

2.1.2 栈帧操作

栈帧的操作主要包括进入和退出函数时的栈帧创建和销毁。以下是具体的流程：

进入函数 ：
- 保存当前的栈指针（SP）。
- 创建新的栈帧，调整栈指针。
- 保存返回地址。
- 保存参数。
- 分配局部变量的空间。
退出函数 ：
- 释放局部变量的空间。
- 恢复保存的寄存器。
- 恢复栈指针。
- 跳转到返回地址。

sequenceDiagram
    participant Caller as 调用者
    participant Callee as 被调用者
    Caller->>Callee: 调用函数
    Callee->>Callee: 保存栈指针
    Callee->>Callee: 创建栈帧
    Callee->>Callee: 保存返回地址
    Callee->>Callee: 保存参数
    Callee->>Callee: 分配局部变量空间
    Callee->>Callee: 执行函数体
    Callee->>Callee: 释放局部变量空间
    Callee->>Callee: 恢复寄存器
    Callee->>Callee: 恢复栈指针
    Callee-->>Caller: 返回结果

2.2 参数传递

参数传递是函数调用的核心部分。参数可以按值传递或按引用传递。按值传递时，参数的值会被复制到栈帧中；按引用传递时，传递的是参数的地址。

2.2.1 参数传递方式

按值传递 ：参数的值被复制到栈帧中。
按引用传递 ：传递参数的地址，函数可以直接修改原始变量。

2.2.2 参数传递流程

参数传递的具体流程如下：

按值传递 ：
- 将参数的值压入栈中。
- 函数调用时从栈中弹出参数值。
按引用传递 ：
- 将参数的地址压入栈中。
- 函数调用时从栈中弹出地址，并通过地址访问原始变量。

graph TD
    A[参数传递] --> B(按值传递)
    A --> C(按引用传递)
    B --> D[将参数值压入栈]
    B --> E[函数调用时弹出参数值]
    C --> F[将参数地址压入栈]
    C --> G[函数调用时弹出地址并访问变量]

3 栈帧（Stack Frame）

栈帧是函数调用时创建的局部存储区域，用于保存函数的局部变量、参数和返回地址。栈帧的结构和操作是编译器设计中的重要内容。

3.1 栈帧的结构

栈帧的结构如下表所示：

字段	描述
返回地址	函数返回后继续执行的地址
参数	传递给函数的参数
局部变量	函数内部声明的局部变量
保存的寄存器	函数调用前保存的寄存器状态

3.2 栈帧的作用

栈帧的主要作用包括：
- 保存返回地址 ：确保函数调用结束后可以正确返回到调用点。
- 保存参数 ：传递给函数的参数。
- 保存局部变量 ：函数内部声明的局部变量。
- 保存寄存器状态 ：函数调用前保存的寄存器状态，确保函数调用结束后可以正确恢复。

3.3 栈帧的创建和销毁

栈帧的创建和销毁发生在函数调用和返回时。以下是具体的流程：

进入函数 ：
- 保存当前的栈指针（SP）。
- 创建新的栈帧，调整栈指针。
- 保存返回地址。
- 保存参数。
- 分配局部变量的空间。
退出函数 ：
- 释放局部变量的空间。
- 恢复保存的寄存器。
- 恢复栈指针。
- 跳转到返回地址。

4 栈操作的代码生成

栈操作的代码生成是编译器设计中的一个重要环节。编译器需要生成进入和退出过程的代码，以确保函数调用和返回时栈帧的正确创建和销毁。

4.1 代码生成的基本原则

代码生成的基本原则包括：
- 保持一致性 ：确保栈帧的创建和销毁操作一致，避免栈溢出或栈损坏。
- 优化性能 ：尽量减少栈操作的次数，提高程序的执行效率。
- 支持调试 ：生成易于调试的代码，便于跟踪和定位问题。

4.2 进入过程的代码生成

进入过程的代码生成主要包括以下步骤：

保存当前栈指针 ：将当前的栈指针保存到寄存器中。
调整栈指针 ：创建新的栈帧，调整栈指针。
保存返回地址 ：将返回地址压入栈中。
保存参数 ：将参数压入栈中。
分配局部变量空间 ：为局部变量分配栈空间。

graph TD
    A[进入过程] --> B(保存栈指针)
    A --> C(调整栈指针)
    A --> D(保存返回地址)
    A --> E(保存参数)
    A --> F(分配局部变量空间)

4.3 退出过程的代码生成

退出过程的代码生成主要包括以下步骤：

释放局部变量空间 ：释放局部变量占用的栈空间。
恢复寄存器 ：恢复保存的寄存器状态。
恢复栈指针 ：恢复栈指针到调用前的状态。
跳转到返回地址 ：跳转到返回地址继续执行。

graph TD
    A[退出过程] --> B(释放局部变量空间)
    A --> C(恢复寄存器)
    A --> D(恢复栈指针)
    A --> E(跳转到返回地址)

5 递归调用的支持

递归调用是函数调用自身的过程。编译器需要确保每次递归调用都有独立的栈帧，以避免栈溢出和数据覆盖。

5.1 递归调用的特点

递归调用的特点包括：
- 独立栈帧 ：每次递归调用都有独立的栈帧。
- 保存返回地址 ：确保每次递归调用都能正确返回。
- 避免栈溢出 ：通过优化栈操作，避免栈溢出。

5.2 递归调用的实现

递归调用的实现主要包括以下步骤：

创建独立栈帧 ：为每次递归调用创建独立的栈帧。
保存返回地址 ：将返回地址压入栈中。
传递参数 ：将参数压入栈中。
递归调用 ：调用自身函数。
释放栈帧 ：递归调用结束后释放栈帧。

graph TD
    A[递归调用] --> B(创建独立栈帧)
    A --> C(保存返回地址)
    A --> D(传递参数)
    A --> E(递归调用)
    A --> F(释放栈帧)

6 栈溢出检测

栈溢出是指栈的大小超出其分配的空间，可能导致程序崩溃。编译器需要实现栈溢出的检测机制，以防止程序崩溃。

6.1 栈溢出的原因

栈溢出的原因包括：
- 无限递归 ：递归调用次数过多，导致栈帧不断增长。
- 大数组 ：局部变量过大，超出栈的容量。
- 内存泄漏 ：栈空间未及时释放，导致栈溢出。

6.2 栈溢出的检测

栈溢出的检测方法包括：
- 栈指针检查 ：定期检查栈指针，确保其在合法范围内。
- 哨兵值 ：在栈的边界处设置哨兵值，检测栈是否越界。
- 栈保护机制 ：通过操作系统提供的保护机制，检测栈溢出。

6.3 栈溢出的处理

栈溢出的处理方法包括：
- 抛出异常 ：检测到栈溢出时，抛出异常，终止程序执行。
- 回滚操作 ：尝试回滚操作，释放栈空间，恢复程序状态。
- 日志记录 ：记录栈溢出的详细信息，便于后续分析。

7 栈的优化

栈的优化是提高程序性能的重要手段。通过优化栈操作，可以减少栈空间的占用，提高程序的执行效率。

7.1 栈空间优化

栈空间优化的方法包括：
- 减少栈帧大小 ：通过优化局部变量的分配，减少栈帧的大小。
- 合并栈帧 ：将多个栈帧合并为一个，减少栈操作的次数。
- 延迟分配 ：延迟局部变量的分配，直到实际使用时才分配栈空间。

7.2 栈操作优化

栈操作优化的方法包括：
- 减少栈操作次数 ：通过优化代码生成，减少栈操作的次数。
- 内联函数 ：将简单的函数内联展开，避免函数调用的栈操作。
- 寄存器优化 ：优先使用寄存器存储变量，减少栈操作的频率。

8 栈的使用实例

为了更好地理解栈的使用，下面通过一个简单的例子来说明栈在函数调用中的作用。

8.1 示例代码

function factorial(n: Integer): Integer;
begin
    if n = 0 then
        factorial := 1
    else
        factorial := n * factorial(n - 1);
end;

begin
    writeln(factorial(5));
end.

8.2 栈帧分析

在调用 factorial(5) 时，栈帧的创建和销毁过程如下：

调用 factorial(5) ：
- 创建栈帧，保存返回地址和参数 n=5 。
- 调用 factorial(4) 。
调用 factorial(4) ：
- 创建栈帧，保存返回地址和参数 n=4 。
- 调用 factorial(3) 。
调用 factorial(3) ：
- 创建栈帧，保存返回地址和参数 n=3 。
- 调用 factorial(2) 。
调用 factorial(2) ：
- 创建栈帧，保存返回地址和参数 n=2 。
- 调用 factorial(1) 。
调用 factorial(1) ：
- 创建栈帧，保存返回地址和参数 n=1 。
- 调用 factorial(0) 。
调用 factorial(0) ：
- 创建栈帧，保存返回地址和参数 n=0 。
- 返回 1 。
返回 factorial(1) ：
- 返回 1 * 1 = 1 。
返回 factorial(2) ：
- 返回 2 * 1 = 2 。
返回 factorial(3) ：
- 返回 3 * 2 = 6 。
返回 factorial(4) ：
- 返回 4 * 6 = 24 。
返回 factorial(5) ：
- 返回 5 * 24 = 120 。

graph TD
    A[调用factorial(5)] --> B(创建栈帧, n=5)
    B --> C(调用factorial(4))
    C --> D(创建栈帧, n=4)
    D --> E(调用factorial(3))
    E --> F(创建栈帧, n=3)
    F --> G(调用factorial(2))
    G --> H(创建栈帧, n=2)
    H --> I(调用factorial(1))
    I --> J(创建栈帧, n=1)
    J --> K(调用factorial(0))
    K --> L(返回1)
    L --> M(返回1 * 1 = 1)
    M --> N(返回2 * 1 = 2)
    N --> O(返回3 * 2 = 6)
    O --> P(返回4 * 6 = 24)
    P --> Q(返回5 * 24 = 120)

9 栈的使用总结

栈在编译器中的使用是编译器设计中的重要内容。栈的主要作用包括支持函数调用、参数传递、局部变量存储等。通过合理使用栈，可以有效地管理和优化程序的运行时环境。栈的优化和栈溢出检测是提高程序性能和稳定性的关键。通过具体的实例，我们可以更好地理解栈在编译器中的应用。

10 栈的使用优化

栈的使用优化是提高程序性能的重要手段。通过优化栈操作，可以减少栈空间的占用，提高程序的执行效率。栈的优化方法包括栈空间优化和栈操作优化。

10.1 栈空间优化

10.2 栈操作优化

11 栈的使用实例

为了更好地理解栈的使用，下面通过一个简单的例子来说明栈在函数调用中的作用。

11.1 示例代码

function factorial(n: Integer): Integer;
begin
    if n = 0 then
        factorial := 1
    else
        factorial := n * factorial(n - 1);
end;

begin
    writeln(factorial(5));
end.

11.2 栈帧分析

在调用 factorial(5) 时，栈帧的创建和销毁过程如下：

调用 factorial(5) ：
- 创建栈帧，保存返回地址和参数 n=5 。
- 调用 factorial(4) 。
调用 factorial(4) ：
- 创建栈帧，保存返回地址和参数 n=4 。
- 调用 factorial(3) 。
调用 factorial(3) ：
- 创建栈帧，保存返回地址和参数 n=3 。
- 调用 factorial(2) 。
调用 factorial(2) ：
- 创建栈帧，保存返回地址和参数 n=2 。
- 调用 factorial(1) 。
调用 factorial(1) ：
- 创建栈帧，保存返回地址和参数 n=1 。
- 调用 factorial(0) 。
调用 factorial(0) ：
- 创建栈帧，保存返回地址和参数 n=0 。
- 返回 1 。
返回 factorial(1) ：
- 返回 1 * 1 = 1 。
返回 factorial(2) ：
- 返回 2 * 1 = 2 。
返回 factorial(3) ：
- 返回 3 * 2 = 6 。
返回 factorial(4) ：
- 返回 4 * 6 = 24 。
返回 factorial(5) ：
- 返回 5 * 24 = 120 。

graph TD
    A[调用factorial(5)] --> B(创建栈帧, n=5)
    B --> C(调用factorial(4))
    C --> D(创建栈帧, n=4)
    D --> E(调用factorial(3))
    E --> F(创建栈帧, n=3)
    F --> G(调用factorial(2))
    G --> H(创建栈帧, n=2)
    H --> I(调用factorial(1))
    I --> J(创建栈帧, n=1)
    J --> K(调用factorial(0))
    K --> L(返回1)
    L --> M(返回1 * 1 = 1)
    M --> N(返回2 * 1 = 2)
    N --> O(返回3 * 2 = 6)
    O --> P(返回4 * 6 = 24)
    P --> Q(返回5 * 24 = 120)

12 栈的使用总结

13 栈的使用优化

13.1 栈空间优化

13.2 栈操作优化

14 栈的使用实例

为了更好地理解栈的使用，下面通过一个简单的例子来说明栈在函数调用中的作用。

14.1 示例代码

function factorial(n: Integer): Integer;
begin
    if n = 0 then
        factorial := 1
    else
        factorial := n * factorial(n - 1);
end;

begin
    writeln(factorial(5));
end.

14.2 栈帧分析

在调用 factorial(5) 时，栈帧的创建和销毁过程如下：

调用 factorial(5) ：
- 创建栈帧，保存返回地址和参数 n=5 。
- 调用 factorial(4) 。
调用 factorial(4) ：
- 创建栈帧，保存返回地址和参数 n=4 。
- 调用 factorial(3) 。
调用 factorial(3) ：
- 创建栈帧，保存返回地址和参数 n=3 。
- 调用 factorial(2) 。
调用 factorial(2) ：
- 创建栈帧，保存返回地址和参数 n=2 。
- 调用 factorial(1) 。
调用 factorial(1) ：
- 创建栈帧，保存返回地址和参数 n=1 。
- 调用 factorial(0) 。
调用 factorial(0) ：
- 创建栈帧，保存返回地址和参数 n=0 。
- 返回 1 。
返回 factorial(1) ：
- 返回 1 * 1 = 1 。
返回 factorial(2) ：
- 返回 2 * 1 = 2 。
返回 factorial(3) ：
- 返回 3 * 2 = 6 。
返回 factorial(4) ：
- 返回 4 * 6 = 24 。
返回 factorial(5) ：
- 返回 5 * 24 = 120 。

graph TD
    A[调用factorial(5)] --> B(创建栈帧, n=5)
    B --> C(调用factorial(4))
    C --> D(创建栈帧, n=4)
    D --> E(调用factorial(3))
    E --> F(创建栈帧, n=3)
    F --> G(调用factorial(2))
    G --> H(创建栈帧, n=2)
    H --> I(调用factorial(1))
    I --> J(创建栈帧, n=1)
    J --> K(调用factorial(0))
    K --> L(返回1)
    L --> M(返回1 * 1 = 1)
    M --> N(返回2 * 1 = 2)
    N --> O(返回3 * 2 = 6)
    O --> P(返回4 * 6 = 24)
    P --> Q(返回5 * 24 = 120)

15 栈的使用总结

16 栈的使用优化

16.1 栈空间优化

16.2 栈操作优化

17 栈的使用实例

为了更好地理解栈的使用，下面通过一个简单的例子来说明栈在函数调用中的作用。

17.1 示例代码

function factorial(n: Integer): Integer;
begin
    if n = 0 then
        factorial := 1
    else
        factorial := n * factorial(n - 1);
end;

begin
    writeln(factorial(5));
end.

17.2 栈帧分析

在调用 factorial(5) 时，栈帧的创建和销毁过程如下：

调用 factorial(5) ：
- 创建栈帧，保存返回地址和参数 n=5 。
- 调用 factorial(4) 。
调用 factorial(4) ：
- 创建栈帧，保存返回地址和参数 n=4 。
- 调用 factorial(3) 。
调用 factorial(3) ：
- 创建栈帧，保存返回地址和参数 n=3 。
- 调用 factorial(2) 。
调用 factorial(2) ：
- 创建栈帧，保存返回地址和参数 n=2 。
- 调用 factorial(1) 。
调用 factorial(1) ：
- 创建栈帧，保存返回地址和参数 n=1 。
- 调用 factorial(0) 。
调用 factorial(0) ：
- 创建栈帧，保存返回地址和参数 n=0 。
- 返回 1 。
返回 factorial(1) ：
- 返回 1 * 1 = 1 。
返回 factorial(2) ：
- 返回 2 * 1 = 2 。
返回 factorial(3) ：
- 返回 3 * 2 = 6 。
返回 factorial(4) ：
- 返回 4 * 6 = 24 。
返回 factorial(5) ：
- 返回 5 * 24 = 120 。

graph TD
    A[调用factorial(5)] --> B(创建栈帧, n=5)
    B --> C(调用factorial(4))
    C --> D(创建栈帧, n=4)
    D --> E(调用factorial(3))
    E --> F(创建栈帧, n=3)
    F --> G(调用factorial(2))
    G --> H(创建栈帧, n=2)
    H --> I(调用factorial(1))
    I --> J(创建栈帧, n=1)
    J --> K(调用factorial(0))
    K --> L(返回1)
    L --> M(返回1 * 1 = 1)
    M --> N(返回2 * 1 = 2)
    N --> O(返回3 * 2 = 6)
    O --> P(返回4 * 6 = 24)
    P --> Q(返回5 * 24 = 120)

18 栈的使用总结

19 栈的使用优化

19.1 栈空间优化

19.2 栈操作优化

20 栈的使用实例

为了更好地理解栈的使用，下面通过一个简单的例子来说明栈在函数调用中的作用。

20.1 示例代码

function factorial(n: Integer): Integer;
begin
    if n = 0 then
        factorial := 1
    else
        factorial := n * factorial(n - 1);
end;

begin
    writeln(factorial(5));
end.

20.2 栈帧分析

在调用 factorial(5) 时，栈帧的创建和销毁过程如下：

调用 factorial(5) ：
- 创建栈帧，保存返回地址和参数 n=5 。
- 调用 factorial(4) 。
调用 factorial(4) ：
- 创建栈帧，保存返回地址和参数 n=4 。
- 调用 factorial(3) 。
调用 factorial(3) ：
- 创建栈帧，保存返回地址和参数 n=3 。
- 调用 factorial(2) 。
调用 factorial(2) ：
- 创建栈帧，保存返回地址和参数 n=2 。
- 调用 factorial(1) 。
调用 factorial(1) ：
- 创建栈帧，保存返回地址和参数 n=1 。
- 调用 factorial(0) 。
调用 factorial(0) ：
- 创建栈帧，保存返回地址和参数 n=0 。
- 返回 1 。
返回 factorial(1) ：
- 返回 1 * 1 = 1 。
返回 factorial(2) ：
- 返回 2 * 1 = 2 。
返回 factorial(3) ：
- 返回 3 * 2 = 6 。
返回 factorial(4) ：
- 返回 4 * 6 = 24 。
返回 factorial(5) ：
- 返回 5 * 24 = 120 。

graph TD
    A[调用factorial(5)] --> B(创建栈帧, n=5)
    B --> C(调用factorial(4))
    C --> D(创建栈帧, n=4)
    D --> E(调用factorial(3))
    E --> F(创建栈帧, n=3)
    F --> G(调用factorial(2))
    G --> H(创建栈帧, n=2)
    H --> I(调用factorial(1))
    I --> J(创建栈帧, n=1)
    J --> K(调用factorial(0))
    K --> L(返回1)
    L --> M(返回1 * 1 = 1)
    M --> N(返回2 * 1 = 2)
    N --> O(返回3 * 2 = 6)
    O --> P(返回4 * 6 = 24)
    P --> Q(返回5 * 24 = 120)

21 栈的使用总结

22 栈的使用优化

22.1 栈空间优化

22.2 栈操作优化

23 栈的使用实例

为了更好地理解栈的使用，下面通过一个简单的例子来说明栈在函数调用中的作用。

23.1 示例代码

function factorial(n: Integer): Integer;
begin
    if n = 0 then
        factorial := 1
    else
        factorial := n * factorial(n - 1);
end;

begin
    writeln(factorial(5));
end.

23.2 栈帧分析

在调用 factorial(5) 时，栈帧的创建和销毁过程如下：

调用 factorial(5) ：
- 创建栈帧，保存返回地址和参数 n=5 。
- 调用 factorial(4) 。
调用 factorial(4) ：
- 创建栈帧，保存返回地址和参数 n=4 。
- 调用 factorial(3) 。
调用 factorial(3) ：
- 创建栈帧，保存返回地址和参数 n=3 。
- 调用 factorial(2) 。
调用 factorial(2) ：
- 创建栈帧，保存返回地址和参数 n=2 。
- 调用 factorial(1) 。
调用 factorial(1) ：
- 创建栈帧，保存返回地址和参数 n=1 。
- 调用 factorial(0) 。
调用 factorial(0) ：
- 创建栈帧，保存返回地址和参数 n=0 。
- 返回 1 。
返回 factorial(1) ：
- 返回 1 * 1 = 1 。
返回 factorial(2) ：
- 返回 2 * 1 = 2 。
返回 factorial(3) ：
- 返回 3 * 2 = 6 。
返回 factorial(4) ：
- 返回 4 * 6 = 24 。
返回 factorial(5) ：
- 返回 5 * 24 = 120 。

graph TD
    A[调用factorial(5)] --> B(创建栈帧, n=5)
    B --> C(调用factorial(4))
    C --> D(创建栈帧, n=4)
    D --> E(调用factorial(3))
    E --> F(创建栈帧, n=3)
    F --> G(调用factorial(2))
    G --> H(创建栈帧, n=2)
    H --> I(调用factorial(1))
    I --> J(创建栈帧, n=1)
    J --> K(调用factorial(0))
    K --> L(返回1)
    L --> M(返回1 * 1 = 1)
    M --> N(返回2 * 1 = 2)
    N --> O(返回3 * 2 = 6)
    O --> P(返回4 * 6 = 24)
    P --> Q(返回5 * 24 = 120)

24 栈的使用总结

25 栈的使用优化

25.1 栈空间优化

25.2 栈操作优化

26 栈的使用实例

为了更好地理解栈的使用，下面通过一个简单的例子来说明栈在函数调用中的作用。

26.1 示例代码

function factorial(n: Integer): Integer;
begin
    if n = 0 then
        factorial := 1
    else
        factorial := n * factorial(n - 1);
end;

begin
    writeln(factorial(5));
end.

26.2 栈帧分析

在调用 factorial(5) 时，栈帧的创建和销毁过程如下：

调用 factorial(5) ：
- 创建栈帧，保存返回地址和参数 n=5 。
- 调用 factorial(4) 。
调用 factorial(4) ：
- 创建栈帧，保存返回地址和参数 n=4 。
- 调用 factorial(3) 。
调用 factorial(3) ：
- 创建栈帧，保存返回地址和参数 n=3 。
- 调用 factorial(2) 。
调用 factorial(2) ：
- 创建栈帧，保存返回地址和参数 n=2 。
- 调用 factorial(1) 。
调用 factorial(1) ：
- 创建栈帧，保存返回地址和参数 n=1 。
- 调用 factorial(0) 。
调用 factorial(0) ：
- 创建栈帧，保存返回地址和参数 n=0 。
- 返回 1 。
返回 factorial(1) ：
- 返回 1 * 1 = 1 。
返回 factorial(2) ：
- 返回 2 * 1 = 2 。
返回 factorial(3) ：
- 返回 3 * 2 = 6 。
返回 factorial(4) ：
- 返回 4 * 6 = 24 。
返回 factorial(5) ：
- 返回 5 * 24 = 120 。

graph TD
    A[调用factorial(5)] --> B(创建栈帧, n=5)
    B --> C(调用factorial(4))
    C --> D(创建栈帧, n=4)
    D --> E(调用factorial(3))
    E --> F(创建栈帧, n=3)
    F --> G(调用factorial(2))
    G --> H(创建栈帧, n=2)
    H --> I(调用factorial(1))
    I --> J(创建栈帧, n=1)
    J --> K(调用factorial(0))
    K --> L(返回1)
    L --> M(返回1 * 1 = 1)
    M --> N(返回2 * 1 = 2)
    N --> O(返回3 * 2 = 6)
    O --> P(返回4 * 6 = 24)
    P --> Q(返回5 * 24 = 120)

27 栈的使用总结

28 栈的使用优化

28.1 栈空间优化

28.2 栈操作优化

29 栈的使用实例

为了更好地理解栈的使用，下面通过一个简单的例子来说明栈在函数调用中的作用。

29.1 示例代码

function factorial(n: Integer): Integer;
begin
    if n = 0 then
        factorial := 1
    else
        factorial := n * factorial(n - 1);
end;

begin
    writeln(factorial(5));
end.

29.2 栈帧分析

在调用 factorial(5) 时，栈帧的创建和销毁过程如下：

调用 factorial(5) ：
- 创建栈帧，保存返回地址和参数 n=5 。
- 调用 factorial(4) 。
调用 factorial(4) ：
- 创建栈帧，保存返回地址和参数 n=4 。
- 调用 factorial(3) 。
调用 factorial(3) ：
- 创建栈帧，保存返回地址和参数 n=3 。
- 调用 factorial(2) 。
调用 factorial(2) ：
- 创建栈帧，保存返回地址和参数 n=2 。
- 调用 factorial(1) 。
调用 factorial(1) ：
- 创建栈帧，保存返回地址和参数 n=1 。
- 调用 factorial(0) 。
调用 factorial(0) ：
- 创建栈帧，保存返回地址和参数 n=0 。
- 返回 1 。
返回 factorial(1) ：
- 返回 1 * 1 = 1 。
返回 factorial(2) ：
- 返回 2 * 1 = 2 。
返回 factorial(3) ：
- 返回 3 * 2 = 6 。
返回 factorial(4) ：
- 返回 4 * 6 = 24 。
返回 factorial(5) ：
- 返回 5 * 24 = 120 。

graph TD
    A[调用factorial(5)] --> B(创建栈帧, n=5)
    B --> C(调用factorial(4))
    C --> D(创建栈帧, n=4)
    D --> E(调用factorial(3))
    E --> F(创建栈帧, n=3)
    F --> G(调用factorial(2))
    G --> H(创建栈帧, n=2)
    H --> I(调用factorial(1))
    I --> J(创建栈帧, n=1)
    J --> K(调用factorial(0))
    K --> L(返回1)
    L --> M(返回1 * 1 = 1)
    M --> N(返回2 * 1 = 2)
    N --> O(返回3 * 2 = 6)
    O --> P(返回4 * 6 = 24)
    P --> Q(返回5 * 24 = 120)

30 栈的使用总结

31 栈的使用优化

31.1 栈空间优化

31.2 栈操作优化

32 栈的使用实例

为了更好地理解栈的使用，下面通过一个简单的例子来说明栈在函数调用中的作用。

32.1 示例代码

function factorial(n: Integer): Integer;
begin
    if n = 0 then
        factorial := 1
    else
        factorial := n * factorial(n - 1);
end;

begin
    writeln(factorial(5));
end.

32.2 栈帧分析

在调用 factorial(5) 时，栈帧的创建和销毁过程如下：

调用 factorial(5) ：
- 创建栈帧，保存返回地址和参数 n=5 。
- 调用 factorial(4) 。
调用 factorial(4) ：
- 创建栈帧，保存返回地址和参数 n=4 。
- 调用 factorial(3) 。
调用 factorial(3) ：
- 创建栈帧，保存返回地址和参数 n=3 。
- 调用 factorial(2) 。
调用 factorial(2) ：
- 创建栈帧，保存返回地址和参数 n=2 。
- 调用 factorial(1) 。
调用 factorial(1) ：
- 创建栈帧，保存返回地址和参数 n=1 。
- 调用 factorial(0) 。
调用 factorial(0) ：
- 创建栈帧，保存返回地址和参数 n=0 。
- 返回 1 。
返回 factorial(1) ：
- 返回 1 * 1 = 1 。
返回 factorial(2) ：
- 返回 2 * 1 = 2 。
返回 factorial(3) ：
- 返回 3 * 2 = 6 。
返回 factorial(4) ：
- 返回 4 * 6 = 24 。
返回 factorial(5) ：
- 返回 5 * 24 = 120 。

graph TD
    A[调用factorial(5)] --> B(创建栈帧, n=5)
    B --> C(调用factorial(4))
    C --> D(创建栈帧, n=4)
    D --> E(调用factorial(3))
    E --> F(创建栈帧, n=3)
    F --> G(调用factorial(2))
    G --> H(创建栈帧, n=2)
    H --> I(调用factorial(1))
    I --> J(创建栈帧, n=1)
    J --> K(调用factorial(0))
    K --> L(返回1)
    L --> M(返回1 * 1 = 1)
    M --> N(返回2 * 1 = 2)
    N --> O(返回3 * 2 = 6)
    O --> P(返回4 * 6 = 24)
    P --> Q(返回5 * 24 = 120)

33 栈的使用总结

34 栈的使用优化

34.1 栈空间优化

34.2 栈操作优化

35 栈的使用实例

为了更好地理解栈的使用，下面通过一个简单的例子来说明栈在函数调用中的作用。

35.1 示例代码

function factorial(n: Integer): Integer;
begin
    if n = 0 then
        factorial := 1
    else
        factorial := n * factorial(n - 1);
end;

begin
    writeln(factorial(5));
end.

35.2 栈帧分析

在调用 factorial(5) 时，栈帧的创建和销毁过程如下：

调用 factorial(5) ：
- 创建栈帧，保存返回地址和参数 n=5 。
- 调用 factorial(4) 。
调用 factorial(4) ：
- 创建栈帧，保存返回地址和参数 n=4 。
- 调用 factorial(3) 。
调用 factorial(3) ：
- 创建栈帧，保存返回地址和参数 n=3 。
- 调用 factorial(2) 。
调用 factorial(2) ：
- 创建栈帧，保存返回地址和参数 n=2 。
- 调用 factorial(1) 。
调用 factorial(1) ：
- 创建栈帧，保存返回地址和参数 n=1 。
- 调用 factorial(0) 。
调用 factorial(0) ：
- 创建栈帧，保存返回地址和参数 n=0 。
- 返回 1 。
返回 factorial(1) ：
- 返回 1 * 1 = 1 。
返回 factorial(2) ：
- 返回 2 * 1 = 2 。
返回 factorial(3) ：
- 返回 3 * 2 = 6 。
返回 factorial(4) ：
- 返回 4 * 6 = 24 。
返回 factorial(5) ：
- 返回 5 * 24 = 120 。

graph TD
    A[调用factorial(5)] --> B(创建栈帧, n=5)
    B --> C(调用factorial(4))
    C --> D(创建栈帧, n=4)
    D --> E(调用factorial(3))
    E --> F(创建栈帧, n=3)
    F --> G(调用factorial(2))
    G --> H(创建栈帧, n=2)
    H --> I(调用factorial(1))
    I --> J(创建栈帧, n=1)
    J --> K(调用factorial(0))
    K --> L(返回1)
    L --> M(返回1 * 1 = 1)
    M --> N(返回2 * 1 = 2)
    N --> O(返回3 * 2 = 6)
    O --> P(返回4 * 6 = 24)
    P --> Q(返回5 * 24 = 120)

36 栈的使用总结

37 栈的使用优化

37.1 栈空间优化

37.2 栈操作优化

38 栈的使用实例

为了更好地理解栈的使用，下面通过一个简单的例子来说明栈在函数调用中的作用。

38.1 示例代码

function factorial(n: Integer): Integer;
begin
    if n = 0 then
        factorial := 1
    else
        factorial := n * factorial(n - 1);
end;

begin
    writeln(factorial(5));
end.

38.2 栈帧分析

在调用 factorial(5) 时，栈帧的创建和销毁过程如下：

调用 factorial(5) ：
- 创建栈帧，保存返回地址和参数 n=5 。
- 调用 factorial(4) 。
调用 factorial(4) ：
- 创建栈帧，保存返回地址和参数 n=4 。
- 调用 factorial(3) 。
调用 factorial(3) ：
- 创建栈帧，保存返回地址和参数 n=3 。
- 调用 factorial(2) 。
调用 factorial(2) ：
- 创建栈帧，保存返回地址和参数 n=2 。
- 调用 factorial(1) 。
调用 factorial(1) ：
- 创建栈帧，保存返回地址和参数 n=1 。
- 调用 factorial(0) 。
调用 factorial(0) ：
- 创建栈帧，保存返回地址和参数 n=0 。
- 返回 1 。
返回 factorial(1) ：
- 返回 1 * 1 = 1 。
返回 factorial(2) ：
- 返回 2 * 1 = 2 。
返回 factorial(3) ：
- 返回 3 * 2 = 6 。
返回 factorial(4) ：
- 返回 4 * 6 = 24 。
返回 factorial(5) ：
- 返回 5 * 24 = 120 。

```mermaid
graph TD
A[调用factorial(5)] –> B(创建栈帧, n=5)
B –> C(调用factorial(4))
C –> D(创建栈帧, n=4)
D –> E(调用factorial(3))
E –> F(创建栈帧, n=3)
F –> G(调用factorial(2))
G –> H(创建栈帧, n=2)
H –> I(调用factorial(1))
I –> J(创建栈帧, n=1)
J –> K(调用factorial(0))
K –> L(返回1)
L –> M(返回1 * 1 = 1)
M –> N(返回2 * 1 = 2)
N –> O(返回3 * 2 =