进程的地址空间

在 Linux 下，一个运行中的程序（进程）拥有一个独立的虚拟地址空间（Virtual Address Space），这个空间是操作系统通过内存管理单元（MMU）和页表机制为每个进程提供的抽象。它描述了一个进程在运行时，其虚拟地址空间是如何组织和划分的。它让每个进程“以为”自己独占整个内存资源，极大简化了程序设计和内存管理。

一、进程内存布局总览

典型的 x86-64 进程虚拟地址空间（Virtual Address Space）通常由以下几个主要区域组成（从低地址到高地址）：

+------------------------+  0x00007FFFFFFFFFFF (≈ 128TB)
|         Stack          |  向下增长（高地址 → 低地址）
|         ...            |
|------------------------|
|                          |
|       MMAP Area          |  动态映射区（mmap, shared libraries, heap 扩展）
|   (共享库、堆、mmap)      |
|                          |
|------------------------|
|                          |
|       Heap (堆)          |  向上增长（malloc/new 分配）
|                          |
|------------------------|
|     Uninitialized Data   |
|        (BSS 段)          |
|------------------------|
|     Initialized Data     |
|        (Data 段)         |
|------------------------|
|      Read-only Data      |
|        (ROData 段)       |
|------------------------|
|       Code (Text)        |
|        (代码段)          |  只读可执行
|------------------------|
|  Program Break (brk)     |
|------------------------|
|       Runtime Code       |
|    (如 VDSO, VVAR)       |
|------------------------|
|     Kernel Space         |  用户不可访问
+------------------------+  0x0000000000000000

注意：64 位系统中，用户空间通常只使用低 48 位地址（0x0000000000000000 ~ 0x00007FFFFFFFFFFF），高地址保留给内核。 💡 注意：现代系统使用虚拟内存，每个进程都有独立的地址空间，互不干扰。

二、各内存区域详解

1. 代码段（Text Segment）

别名：文本段、只读代码段
来源：ELF 文件中的 .text 节区
内容：存放程序的机器指令（即编译后的可执行代码）
权限：read + execute（通常不可写，防止代码被篡改）(r-x）
共享：多个进程运行同一程序时，该段可以共享（节省内存）
位置：固定地址（由链接器决定）
大小：编译时确定

📌 示例：

void hello() {
    printf("Hello\n");  // 这行代码的机器指令存在 Text 段
}

2. 只读数据段（.rodata）

内容：存放只读常量数据，如：
- 字符串字面量："Hello World"
- const 全局变量（在某些编译器下）
- 数组初始化常量
权限：read-only（r—）
目的：防止程序意外修改常量，提高安全性
来源：ELF 中的 .rodata 节区
特点：与代码段常一起映射，提高缓存效率

📌 示例：

const char* msg = "I am read-only";

→ "I am read-only" 存在 .rodata 段

3. 已初始化数据段（Data Segment）

内容：存放已初始化的全局变量和静态变量
权限：read + write（rw-）
来源：ELF 中的 .data 节区
特点：大小在编译时确定，随程序加载到内存

📌 示例：

int global_var = 100;        // 在 data 段
static int static_var = 42;  // 在 data 段

4. 未初始化数据段（BSS Segment）

全称：Block Started by Symbol
内容：存放未初始化的全局变量和静态变量
权限：read + write（rw-）
来源：ELF 中的 .bss 节区（不占用文件空间，只记录大小）
特点：
- C 语言初始值默认为 0
- 不占用可执行文件空间（只记录大小），加载时由操作系统清零
- 节省磁盘和内存空间
- 加载时由操作系统清零
- 大小在编译时确定

📌 示例：

int uninitialized_global;     // 在 BSS 段
static float f;               // 在 BSS 段（自动初始化为 0.0）

📌 BSS 不包含在可执行文件中，但会在程序加载时分配并清零。

5. 堆（Heap）

用途：动态内存分配（如 malloc, calloc, realloc, new）
管理：由程序员手动申请和释放（或由 GC 管理）
权限：read + write（rw-）
增长方向：向上增长（从低地址向高地址）
管理方式：
- 通过系统调用 brk() 和 sbrk() 扩展堆顶（program break）
- malloc 库函数在堆上管理内存块（有内存池、空闲链表等机制）
碎片问题：容易产生内存碎片（外部碎片）

📌 示例：

int *p = (int*)malloc(100 * sizeof(int));  // 分配在堆上

📌 malloc 小块内存通常用 brk 扩展堆；大块内存用 mmap 映射匿名页。

6. 栈（Stack）

用途：存放函数调用信息：
- 局部变量
- 函数参数
- 返回地址
- 栈帧（stack frame）管理
管理：由编译器自动生成指令，自动分配和释放
权限：read write（rw-），通常不可执行（防止栈溢出攻击）
增长方向：向下增长（从高地址向低地址）
大小限制：通常有限（如 Linux 默认 8MB，可用 ulimit -s 查看）
线程栈：每个线程有自己的栈（主线程栈在进程启动时创建，其他线程栈由 pthread_create 分配）
特点：
- 自动分配/释放（函数调用结束自动回收）
- 后进先出（LIFO）
- 多线程程序中每个线程有独立的栈

📌 示例：

void func(int x) {
    int local = x * 2;  // local 和 x 都在栈上
}

📌 栈溢出（如递归太深、大数组）会导致 Segmentation Fault。

7. 内存映射区（Memory Mapping Segment）

权限：根据映射内容决定（如库为 r-x，数据为 rw-）
别名：文件映射区、mmap 区
地址范围：通常位于栈和堆之间（现代 Linux 中可能在更高地址）
用途：
- 映射共享库（如 libc.so）
- mmap() 映射文件
- 大块内存分配（malloc 对大内存使用 mmap）
- 匿名映射（用于进程间共享内存）
特点：
- 可以映射文件到内存，实现“内存访问即文件读写”
- 支持共享映射（多个进程共享同一物理页）
- 增长方向：不固定，按需映射
- 灵活，支持文件映射、共享内存
- 不受 brk 限制

📌 示例：

void *ptr = mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);

8. 环境变量与命令行参数区

位置：通常位于栈的最顶端（最高地址附近）
内容：
- argv[]：命令行参数
- envp[]：环境变量（如 PATH, HOME）
传递方式：由 execve 系统调用加载到进程地址空间

📌 进程启动时，main 函数的参数就来自这里：

int main(int argc, char *argv[], char *envp[])

三、32 位 Vs 64 位地址空间差异

架构	总虚拟地址空间	用户空间	内核空间
32 位	4 GB (2^32)	~3 GB	~1 GB
64 位	极大（2^48 或 2^57）	极大	极大

64 位系统地址空间远大于实际物理内存，支持更大的堆和更多映射。
64 位下栈通常从高位地址开始向下增长。

四、如何查看进程内存布局？

1. 查看 `/proc/<pid>/maps`

cat /proc/self/maps

输出示例：

00400000-00401000 r-xp 00000000 08:01 123456 /path/to/program
00600000-00601000 r--p 00000000 08:01 123456 /path/to/program
00601000-00602000 rw-p 00001000 08:01 123456 /path/to/program
7ffff7a00000-7ffff7bcd000 r-xp 00000000 08:01 789012 /lib/x86_64-linux-gnu/libc.so.6
7ffff7bcd000-7ffff7dcd000 ---p 001cd000 08:01 789012 /lib/x86_64-linux-gnu/libc.so.6
7ffff7dcd000-7ffff7dd1000 r--p 001cd000 08:01 789012 /lib/x86_64-linux-gnu/libc.so.6
7ffff7dd1000-7ffff7dd3000 rw-p 001d1000 08:01 789012 /lib/x86_64-linux-gnu/libc.so.6
7ffffffde000-7ffffffff000 rw-p 00000000 00:00 0      [stack]

字段含义：

地址范围
权限（r 读 w 写 x 执行 p 私有 s 共享）
偏移、设备、inode、文件名

2. 使用 `pmap` 命令

pmap <pid>

3. 使用 `size` 命令查看可执行文件段大小

size a.out
# 输出：text    data     bss     dec     hex filename

五、常见问题与安全

问题	原因	防范
栈溢出	递归过深、大数组	限制递归深度、使用堆分配
堆溢出	写越界	使用边界检查工具（如 AddressSanitizer）
内存泄漏	`malloc` 后未 `free`	使用智能指针、垃圾回收、工具检测
野指针	使用已释放内存	释放后置 NULL
缓冲区溢出攻击	栈上数组溢出覆盖返回地址	栈保护（Stack Canary）、ASLR、NX bit

六、总结：进程内存布局核心要点

区域	内容	增长方向	管理方式
Text	可执行代码	-	链接器
.rodata	只读常量	-	编译器
Data	已初始化全局/静态变量	-	链接器
BSS	未初始化全局/静态变量	-	操作系统（加载时清零）
Heap	动态分配内存	↑（向上）	`malloc` / `free`
Memory Mapping	共享库、mmap 文件	-	`mmap` / `munmap`
Stack	局部变量、函数调用	↓（向下）	编译器自动管理
Env/Args	命令行参数、环境变量	-	`execve` 加载

✅ 学习建议

写一个简单程序，打印不同变量的地址（全局、静态、局部、malloc），观察分布。
使用 gdb 调试，查看栈帧和寄存器。
实践 /proc/self/maps 和 pmap。

掌握进程内存模型，是迈向系统级编程、性能优化和安全攻防的关键一步。

栈帧

要理解函数栈帧 Stack Frame，需要从程序内存管理的基础概念入手。在计算机程序中，” 栈 “（Stack）是一种特殊的内存区域，与 ” 堆 “（Heap）共同构成了程序运行时的动态内存空间，但两者的管理方式和用途截然不同。

一、栈与栈帧的基本概念

栈是一种遵循后进先出（LIFO） 原则的线性数据结构，由操作系统或编译器自动管理。程序运行时，每当发生函数调用，系统会在栈上为该函数分配一块独立的内存区域，称为栈帧（Stack Frame）。每个函数的栈帧都是独立的，仅在函数执行期间存在。

二、函数栈帧的分配时机

函数的栈帧在函数被调用的瞬间分配，具体流程如下：

当程序执行到函数调用语句（如 func(a, b)）时，首先将函数的参数、调用者的返回地址（即函数执行完后应回到的代码位置）依次压入栈中；
进入函数内部后，系统会为该函数分配栈帧，用于存储函数的局部变量、寄存器状态（如基址指针 EBP）等；
函数执行结束时，栈帧会被自动释放（局部变量、参数等数据从栈中弹出），程序根据之前保存的返回地址回到调用者继续执行。

三、函数栈帧的核心作用

栈帧是函数运行的 ” 临时工作台 “，主要作用包括：

存储函数参数 函数调用时传递的参数（如 func(a, b) 中的 a 和 b）会被压入栈帧，供函数内部读取使用。参数的压栈顺序通常与调用顺序相反（如 C 语言中是从右到左）。
存储局部变量 函数内部定义的局部变量（如 int x = 5;）会直接分配在栈帧中。这些变量的生命周期与函数执行周期一致：函数开始时创建，函数结束时随栈帧释放。
保存返回地址 函数执行完毕后，需要回到调用者的下一条指令继续运行，这个 ” 返回地址 ” 会被提前压入栈帧，确保程序流程不中断。
维护栈帧上下文 栈帧会保存调用者的栈帧基址（如 EBP 寄存器的值），以便函数执行完后能正确恢复调用者的栈状态，保证栈的连续性。

四、栈帧使用的限制

栈的自动管理机制带来了高效性，但也存在严格限制：

空间大小有限 栈的总大小是固定的（由操作系统预先分配，通常在几 MB 到几十 MB 之间，可通过编译选项或系统配置调整，但远小于堆）。如果函数的局部变量过大（如定义 int arr[1000000]; 这样的大数组），或函数递归调用过深（每次递归都会分配新栈帧），会导致栈空间耗尽，触发栈溢出（Stack Overflow） 错误，程序直接崩溃。
生命周期受函数调用限制 栈帧中的局部变量仅在函数执行期间有效。函数返回后，栈帧被释放，变量的内存地址不再受系统保护（可能被后续栈操作覆盖），此时若通过指针访问已释放的局部变量，会导致野指针错误（结果不可预测）。
分配与释放完全自动 栈帧的分配和释放由编译器或操作系统自动完成，开发者无法手动控制（例如，不能像堆内存那样手动申请延长局部变量的生命周期）。
内存连续性限制 栈是连续的内存区域，无法像堆那样动态调整单个变量的内存大小（例如，栈上的数组长度必须是编译期确定的常量，而堆上的动态数组可在运行时调整）。

总结

函数的栈帧是函数调用时在栈上自动分配的临时内存区域，用于支撑函数的参数传递、局部变量存储和程序流程跳转。其高效性（连续内存、自动管理）使其成为函数运行的核心，但有限的空间和严格的生命周期限制，要求开发者避免在栈上存储过大数据或编写过深的递归逻辑，否则易引发栈溢出等问题。

堆栈的分配

栈区分配内存比堆区快得多。

这是一个在系统编程和性能优化中非常关键的区别。主要原因如下：

1. 分配机制的本质不同

栈区 (Stack):
- 机制: 分配和释放内存的操作极其简单，本质上就是移动栈指针 (Stack Pointer)。
- 过程: 当一个函数被调用时，需要为它的局部变量分配空间。系统只需将栈指针向下（或向上，取决于架构）移动 n 个字节（n 是所有局部变量大小的总和）。这个操作通常由一条或几条非常快速的 CPU 指令（如 sub esp, n 在 x86 上）完成。
- 释放: 当函数返回时，栈指针被移回原来的位置，所有局部变量占用的空间“自动”被释放。这个操作同样只需要一条指令（如 mov esp, ebp）。
堆区 (Heap):
- 机制: 分配和释放内存是一个复杂的系统级操作，需要调用运行时库（如 C 语言的 malloc/free）或操作系统的 API（如 sbrk/mmap）。
- 过程:
  1. 查找空闲块: malloc 必须在堆的内存池中搜索一个足够大的、未被使用的内存块。这可能涉及遍历空闲链表、使用最佳/首次适应算法等。
  2. 管理元数据: 需要维护复杂的元数据来记录哪些内存块被使用、哪些空闲、大小是多少。malloc 通常会在分配的内存块前（或后）存储这些信息。
  3. 可能的系统调用: 如果当前堆空间不足，malloc 可能需要通过 sbrk 或 mmap 系统调用向操作系统申请更多的虚拟内存。
  4. 碎片处理: 长期使用会产生内存碎片，malloc 需要处理碎片合并等问题。
- 释放: free 需要将内存块标记为空闲，并可能将其与相邻的空闲块合并，更新元数据结构。这个过程也比栈操作复杂得多。

2. 性能对比总结

特性	栈区 (Stack)	堆区 (Heap)
分配速度	极快 (几条 CPU 指令)	慢 (复杂算法，可能涉及系统调用)
释放速度	极快 (函数返回时自动完成)	慢 (需要 `free` 调用，管理元数据)
管理开销	极低 (仅栈指针)	高 (元数据、链表、算法)
内存碎片	无 (后进先出，顺序分配/释放)	有 (随机分配/释放导致)
生命周期	由作用域决定 (函数调用/返回)	手动管理 (`malloc`/`free`)
大小限制	通常较小 (几 MB 到几 MB，可配置)	通常很大 (受限于虚拟内存)
访问速度	快 (局部性好，缓存友好)	快 (但可能因碎片导致局部性差)

3. 为什么栈这么快？

硬件支持: 栈的操作（压栈 push、弹栈 pop、调整指针）是 CPU 的基本指令，由硬件直接高效支持。
简单性: 逻辑极其简单，遵循严格的后进先出 (LIFO) 原则。分配和释放的顺序是确定的，不需要复杂的搜索和管理。
局部性好: 连续的函数调用产生的栈帧在内存中是连续或接近连续的，对 CPU 缓存非常友好。

4. 为什么堆这么慢？

软件管理: 整个过程由运行时库的软件代码管理，涉及复杂的逻辑和数据结构。
非确定性: 分配和释放的顺序是随机的，malloc 无法预测下一个请求的大小和时间。
系统调用开销: 向操作系统申请或释放内存区域是昂贵的操作，会陷入内核态。
碎片问题: 需要不断处理内存碎片，增加了管理复杂度。

结论

栈区分配内存的速度远超堆区。栈的分配/释放是编译器生成的简单指针移动，而堆的分配/释放是涉及复杂算法和潜在系统调用的重量级操作。

因此，在性能敏感的代码中，应尽可能使用栈内存（局部变量）。只有在以下情况才使用堆内存：

对象的大小在编译时未知，或可能非常大（超过栈限制）。
对象的生命周期需要超出创建它的函数的作用域（例如，需要返回一个在函数内部分配的对象）。
实现动态数据结构（如链表、树、动态数组），其大小在运行时变化。

简单来说：能用栈就用栈，栈不够用或生命周期需要更长时才用堆。

堆栈的大小管理

一、堆栈的大小管理

堆栈的大小管理涉及初始大小设定、动态扩展机制、最大限制以及溢出处理。

1.1 初始栈大小

操作系统默认值：
- Linux：主线程栈默认大小通常为 8MB（可通过 ulimit -s 查看或修改）。
- Windows：默认线程栈为 1MB（可配置）。
- macOS：主线程栈为 8MB，子线程为 512KB。
线程栈大小：创建线程时可指定栈大小（如 pthread_attr_setstacksize()）。

示例：Linux 下查看栈大小
ulimit -s  # 输出 8192（KB），即 8MB

1.2 动态扩展（Stack Growth）

栈通常从高地址向低地址“生长”。
操作系统使用虚拟内存机制，只映射栈的初始部分到物理内存。
当程序访问未映射的栈内存时，触发缺页异常（Page Fault）。
内核检查访问地址是否在合法栈范围内，若是，则分配新的物理页并映射，实现按需扩展。
扩展有上限，防止无限增长。

1.3 保护页（Guard Page）

在栈的边界（通常是底部）设置一个不可访问的内存页作为“警戒页”。
当栈增长触及保护页时，触发缺页异常，内核判断是否允许扩展。
若超出最大栈大小，则终止进程（如发送 SIGSEGV 信号）。

1.4 栈溢出（Stack Overflow）

原因：递归过深、局部变量过大、无限调用。
后果：覆盖相邻内存，导致程序崩溃或安全漏洞。
检测：
- 编译器插入栈金丝雀（Stack Canary） 检测溢出。
- 调试工具（如 Valgrind、AddressSanitizer）可检测栈越界。

二、堆栈的空间分配机制

堆栈的空间分配是操作系统与硬件协同完成的，涉及虚拟内存、物理内存、栈指针管理。

2.1 虚拟地址空间布局

在典型的用户进程地址空间中，栈位于高地址区域，与堆相对生长：

高地址
+------------------+
| 程序栈 (Stack)   | ← 向下增长（向低地址）
+------------------+
|                  |
|     空洞         |
|                  |
+------------------+
|     堆 (Heap)    | ← 向上增长（向高地址）
+------------------+
| 数据段 (Data)    |
+------------------+
| 代码段 (Text)    |
低地址

2.2 栈的内存映射

操作系统通过 mmap() 或内部机制为栈分配虚拟地址区间。
初始只映射少量物理页（如 1~2 页，每页 4KB）。
随着 push 操作，栈指针（SP）递减，访问新地址时触发缺页，内核动态映射新页。

2.3 栈指针（Stack Pointer, SP）管理

SP 寄存器始终指向当前栈顶。
push 操作：先递减 SP，再写入数据（满递减栈，Full Descending）。
pop 操作：先读取数据，再递增 SP。
帧指针（Frame Pointer, FP）用于定位栈帧基址，便于调试和异常处理。

2.4 多线程环境下的栈分配

每个线程有独立的栈，避免数据竞争。
线程栈在堆上分配（由线程库如 pthread 管理），然后设置 SP 指向该区域。
主线程栈由操作系统在进程启动时分配。

三、时间与空间复杂度分析

3.1 时间复杂度

操作	时间复杂度	说明
`push` / `pop`	O(1)	仅修改栈指针，写入/读取内存
函数调用	O(1)	压入返回地址、参数、保存寄存器
局部变量访问	O(1)	通过帧指针 + 偏移量直接寻址
栈扩展（缺页）	O(1) 摊销	虽然单次缺页开销大，但频率低，摊销后仍为常数

⚠️ 注意：虽然 push/pop 是 O(1)，但大量递归调用可能导致栈溢出，实际性能受内存限制。

3.2 空间复杂度

场景	空间复杂度	说明
单个函数调用	O(1)	栈帧大小固定
递归深度为 n	O(n)	每层调用占用常量栈空间
深度优先搜索（DFS）	O(h)	h 为树/图的最大深度
尾递归优化	O(1)	编译器重用栈帧，避免增长

✅ 优化：尾递归可被编译器优化为循环，避免栈空间增长。

四、复杂度设计与系统权衡

堆栈的设计在效率、安全、灵活性之间进行权衡。

4.1 效率 Vs 安全

设计选择	效率	安全
硬件支持 push/pop	⬆️ 高	⬇️ 依赖软件保护
栈金丝雀（Canary）	⬇️ 少量开销	⬆️ 防溢出攻击
非执行栈（NX bit）	⬇️ 无性能损失	⬆️ 防代码注入
地址空间布局随机化（ASLR）	⬇️ 极小开销	⬆️ 增加攻击难度

4.2 固定大小 Vs 动态扩展

方式	优点	缺点
固定大小	简单、预测性强	易溢出或浪费空间
动态扩展	灵活、节省内存	缺页开销、管理复杂

现代系统采用动态扩展 + 最大限制的折中方案。

4.3 栈增长方向设计

多数架构（x86, ARM）采用向下增长（高→低地址）。
原因：
- 与堆相向而行，最大化利用地址空间。
- 溢出检测更直观（SP < 栈底）。

4.4 编译器优化对栈的影响

栈帧合并：多个函数共享栈帧，减少开销。
寄存器分配：尽可能使用寄存器存储变量，减少栈访问。
内联展开（Inlining）：消除函数调用，避免栈帧创建。

五、实际案例与调优建议

5.1 避免栈溢出的编程实践

// ❌ 危险：大数组在栈上
void bad_func() {
    int huge_array[1000000]; // 可能导致栈溢出
}
 
// ✅ 正确：使用堆分配
void good_func() {
    int *arr = malloc(1000000 * sizeof(int));
    // ...
    free(arr);
}

5.2 调整栈大小（Linux）

# 临时修改最大栈大小（单位 KB）
ulimit -s 16384  # 设置为 16MB
 
# 在程序中设置线程栈大小
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, 2 * 1024 * 1024); // 2MB
pthread_create(&thread, &attr, thread_func, NULL);

5.3 使用工具检测栈问题

Valgrind：valgrind --tool=memcheck ./program
AddressSanitizer：编译时加 -fsanitize=address
GDB：调试栈帧、查看 SP/FP 寄存器

六、总结

维度	设计要点
大小管理	默认大小 + 动态扩展 + 保护页 + 最大限制
空间分配	虚拟内存映射 + 缺页机制 + 独立线程栈
时间复杂度	`push/pop` 为 O(1)，函数调用高效
空间复杂度	递归为 O(n)，尾递归可优化为 O(1)
设计理念	效率优先、自动管理、安全防护、硬件协同

堆栈的设计体现了计算机系统在性能、安全、简洁性之间的精妙平衡。理解其底层机制，有助于编写高效、安全的系统级程序，并有效诊断和避免栈相关的问题（如溢出、崩溃）。在系统编程、嵌入式开发和性能优化中，掌握堆栈的管理细节至关重要。

Quartz 4

Explorer

虚拟地址空间

进程的地址空间

一、进程内存布局总览

二、各内存区域详解

1. 代码段（Text Segment）

2. 只读数据段（.rodata）

3. 已初始化数据段（Data Segment）

4. 未初始化数据段（BSS Segment）

5. 堆（Heap）

6. 栈（Stack）

7. 内存映射区（Memory Mapping Segment）

8. 环境变量与命令行参数区

三、32 位 Vs 64 位 地址空间差异

四、如何查看进程内存布局？

1. 查看 /proc/<pid>/maps

2. 使用 pmap 命令

3. 使用 size 命令查看可执行文件段大小

五、常见问题与安全

六、总结：进程内存布局核心要点

✅ 学习建议

栈帧

一、栈与栈帧的基本概念

二、函数栈帧的分配时机

三、函数栈帧的核心作用

四、栈帧使用的限制

总结

堆栈的分配

1. 分配机制的本质不同

2. 性能对比总结

3. 为什么栈这么快？

4. 为什么堆这么慢？

结论

堆栈的大小管理

一、堆栈的大小管理

1.1 初始栈大小

1.2 动态扩展（Stack Growth）

1.3 保护页（Guard Page）

1.4 栈溢出（Stack Overflow）

二、堆栈的空间分配机制

2.1 虚拟地址空间布局

2.2 栈的内存映射

2.3 栈指针（Stack Pointer, SP）管理

2.4 多线程环境下的栈分配

三、时间与空间复杂度分析

3.1 时间复杂度

3.2 空间复杂度

四、复杂度设计与系统权衡

4.1 效率 Vs 安全

4.2 固定大小 Vs 动态扩展

4.3 栈增长方向设计

4.4 编译器优化对栈的影响

五、实际案例与调优建议

5.1 避免栈溢出的编程实践

5.2 调整栈大小（Linux）

5.3 使用工具检测栈问题

六、总结

Graph View

Table of Contents

Backlinks

三、32 位 Vs 64 位地址空间差异

1. 查看 `/proc/<pid>/maps`

2. 使用 `pmap` 命令

3. 使用 `size` 命令查看可执行文件段大小