【C语言入门】内存布局：栈（局部变量）、堆（动态分配）、数据段（全局/静态）、代码段

关注

原创最新推荐文章于 2026-04-23 11:31:10 发布 1.1k 阅读 AI 写同款· GEO 优化 ›

【C语言】内存区域划分及分配及变量知识总结（全局变量、局部变量）一、内存区域划分与分配： 1、栈区（stack）——程序运行时由编译器自动分配，存放函数的参数值，局部变量的值等，程序结束时由编译器自动释放。 2、堆区（heap）——在内存开辟另一块存储区域。一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。用malloc, calloc, realloc等分配内存的函数分配得到的就是在堆上。 3、全局区（静态区）（static）——... 阅读详情

引言：为什么要懂内存布局？

C 语言被称为 “接近底层的高级语言”，核心优势是直接操作内存。但如果不理解内存布局，写程序时可能遇到各种 “玄学问题”：

局部变量突然被 “篡改”（栈溢出）；
malloc后忘记free，程序越跑越慢（内存泄漏）；
修改常量字符串导致崩溃（段错误）。
理解内存布局，相当于拿到了 “程序的地图”，能让你更高效地调试、优化代码，甚至写出更安全的系统级软件（如操作系统、嵌入式程序）。

1. C 程序的内存布局：从 “虚拟地址空间” 说起

现代操作系统（如 Linux、Windows）为每个程序分配了独立的 “虚拟地址空间”（32 位系统 4GB，64 位系统更大）。这个空间被划分为几个固定区域，分别对应代码段、数据段、堆、栈，以及其他辅助区域（如命令行参数、环境变量）。

2. 代码段（Text Segment）：程序的 “操作手册”

2.1 定义与特点

代码段（又称.text段）是内存中只读且可执行的区域，存储程序的机器指令（CPU 实际执行的二进制代码）和常量数据（如字符串字面量、数值常量）。

关键特性：

只读：防止程序意外修改自身代码（比如手滑写了"hello"[0]='H'，会触发 “段错误”）。
可执行：CPU 从这里读取指令并执行（操作系统通过 “NX 位” 标记该区域是否可执行，防止缓冲区溢出攻击）。

2.2 存储内容

机器指令：编译器将 C 代码编译为二进制指令（如add、mov），存储在此处。
字符串字面量：如char* str = "hello";中的"hello"，存储在代码段（注意：str变量本身是局部变量，存在栈里，只是它指向代码段的字符串）。
数值常量：如const int a=10;（注意：C 语言中const变量默认存数据段，除非用static const修饰，可能被优化到代码段）。

2.3 示例与验证

#include <stdio.h>

int main() {
    char* str = "hello"; // "hello"在代码段
    printf("%p\n", str); // 打印字符串地址
    return 0;
}

编译后运行（Linux 下用gcc test.c -o test），用objdump -t test查看符号表，会发现"hello"的地址落在.text段范围内。

3. 数据段（Data Segment）：程序的 “仓库”

数据段是存储全局变量和静态变量的区域，分为两个子段：.data段（已初始化数据）和.bss段（未初始化数据）。

3.1 .data 段：“已初始化的仓库”

存储已初始化的全局变量和静态变量。
示例：

int global_init = 10; // 全局已初始化，.data段
static int static_init = 20; // 静态已初始化，.data段

特点：

程序启动时由操作系统分配内存，初始值为代码中指定的值。
在可执行文件（如.exe、.elf）中占空间（因为需要保存初始化值）。

3.2 .bss 段：“未初始化的仓库”

存储未初始化的全局变量和静态变量（默认初始化为 0）。
示例：

int global_uninit; // 全局未初始化，.bss段（默认0）
static int static_uninit; // 静态未初始化，.bss段（默认0）

特点：

程序启动时分配内存，初始值为 0（无需在可执行文件中保存数据，仅记录大小，节省空间）。
若全局变量显式初始化为 0（如int global_zero=0;），编译器可能将其优化到.bss段（因为 0 是默认值）。

3.3 全局变量 vs 静态变量

特性	全局变量	静态变量（文件内 static）	函数内 static 变量
作用域	整个程序（其他文件用 extern 声明可访问）	本文件内	本函数内
生命周期	程序启动到结束	程序启动到结束	程序启动到结束
存储位置	.data（已初始化）或.bss（未初始化）	.data（已初始化）或.bss（未初始化）	.data（已初始化）或.bss（未初始化）

3.4 验证：查看.data 和.bss 大小

Linux 下编译程序后，用size test命令可以看到各段大小：

   text    data     bss     dec     hex filename
   1234    567      890    2691    a83 test

其中data是.data段大小，bss是.bss段大小。

4. 栈（Stack）：函数的 “临时舞台”

栈是内存中向下增长（向低地址方向）的区域，用于存储函数调用相关数据（局部变量、函数参数、返回地址、栈帧指针）。

4.1 栈的工作原理：后进先出（LIFO）

当函数被调用时，CPU 会执行以下操作（以 x86 架构为例）：

压栈（Push）：将函数参数（从右到左）、返回地址（调用函数的下一条指令地址）、旧栈帧指针（ebp）压入栈。
分配局部变量空间：调整栈顶指针（esp），为局部变量腾出空间。
执行函数体：使用栈中的局部变量和参数。
弹栈（Pop）：函数结束时，恢复栈顶指针（释放局部变量），弹出旧栈帧指针和返回地址，跳回调用函数。

4.2 栈帧结构：函数的 “专属空间”

每个函数在栈中对应一个 “栈帧”（Stack Frame），包含：

参数区：函数参数（如int func(int a, int b)中的a和b）。
返回地址：调用该函数的下一条指令地址（函数执行完后跳回这里）。
帧指针（ebp）：指向当前栈帧的起始位置（用于定位局部变量和参数）。
局部变量区：函数内定义的局部变量（如int c = a + b;中的c）。

4.3 局部变量的 “临时” 本质

局部变量的生命周期仅为函数调用期间。函数结束后，栈帧被销毁，局部变量的内存被回收（但内存中的数据不会被立即清空，只是 “标记为可用”）。因此，绝不能返回局部变量的地址：

int* get_num() {
    int num = 10; // num在栈中，函数结束后被回收
    return &num; // 危险！返回了已失效的地址
}

调用get_num()后，指针指向的内存可能被其他函数覆盖，导致不可预期的错误。

4.4 栈溢出：“餐盘堆太高会塌”

栈的大小是有限的（Linux 默认约 8MB，可通过ulimit -s查看）。如果局部变量太大（如int arr[1000000];）或函数递归过深（如无限递归），会导致栈溢出（Stack Overflow），程序崩溃（核心转储）。

5. 堆（Heap）：动态内存的 “自由市场”

堆是内存中向上增长（向高地址方向）的区域，用于存储动态分配的内存（通过malloc、calloc、realloc申请）。

5.1 为什么需要堆？

栈的局限性：

大小固定（不能存太大数据）；
生命周期固定（函数结束即回收）。
堆的优势：
动态分配（需要多少申请多少）；
生命周期可控（手动释放，可跨函数使用）。

5.2 动态内存分配函数

函数	作用	示例
`malloc(size_t size)`	申请`size`字节的连续内存（初始值随机）	`int* p = malloc(10*sizeof(int));`（申请 40 字节）
`calloc(size_t num, size_t size)`	申请`num`个`size`字节的内存（初始化为 0）	`int* p = calloc(10, sizeof(int));`（等价于`malloc`+`memset`）
`realloc(void* ptr, size_t new_size)`	调整已分配内存的大小（可能移动位置）	`p = realloc(p, 20*sizeof(int));`（扩大到 80 字节）
`free(void* ptr)`	释放已分配的内存（必须由`malloc`等函数返回的指针）	`free(p); p=NULL;`（避免野指针）

5.3 堆的管理机制：操作系统与内存分配器

堆的底层由操作系统（如 Linux 的brk/sbrk系统调用）管理，但直接调用系统调用效率低，因此 C 标准库（如 glibc）实现了内存分配器（如 ptmalloc2），负责：

空闲块管理：用链表记录空闲内存块（如隐式链表、显式链表）。
合并与分割：释放内存时合并相邻空闲块（减少碎片）；分配时分割大空闲块（提高利用率）。
内存对齐：保证分配的内存地址符合 CPU 访问要求（如 x86 要求 4 字节对齐，x86_64 要求 8 字节对齐）。

5.4 常见堆操作错误

内存泄漏（Memory Leak）：申请内存后未free，导致内存逐渐被占满（长期运行的程序如服务器易受影响）。
野指针（Dangling Pointer）：释放内存后仍使用指针（或指针未置NULL，再次访问已释放的内存）。
越界访问：写入超过分配内存的范围（如malloc(10)后写入第 11 个字节），导致堆块 metadata 被破坏（“堆腐败”）。

6. 内存布局的实际观察：工具与技巧

要深入理解内存布局，可以通过以下工具 “亲眼看到” 各区域的位置：

6.1 `objdump`：查看可执行文件的段信息

Linux 下用objdump -h test查看可执行文件的段头部，会显示.text（代码段）、.data（已初始化数据段）、.bss（未初始化数据段）的大小和偏移量。

6.2 `gdb`：调试时查看变量地址

在 gdb 中运行程序，用p &变量名打印地址，根据地址范围判断所在段：

代码段地址较低（如 0x400000 左右）；
数据段地址较高（如 0x600000 左右）；
堆地址在数据段之上（动态分配，每次运行可能不同）；
栈地址最高（如 0x7fffffff 左右，向下增长）。

6.3 `/proc/self/maps`：查看进程的内存映射

Linux 下运行程序时，cat /proc/self/maps会显示进程的内存区域分布，包括各段的起始地址、权限（如r-xp表示只读可执行，对应代码段；rw-p表示可读可写，对应数据段、堆、栈）。

7. 扩展：内存布局的 “边界情况” 与注意事项

7.1 常量字符串的存储位置

C 语言中，char* str = "hello";的"hello"是字符串字面量，存储在代码段（只读）。如果尝试修改str[0]='H'，会触发段错误（因为代码段不可写）。

7.2 `const`变量的存储位置

C 语言的const变量只是 “只读”，本质还是变量，默认存储在数据段（可通过指针修改，尽管这是未定义行为）。例如：

const int a = 10; // 存.data段
int* p = (int*)&a;
*p = 20; // 可能成功（取决于编译器优化），但强烈不建议！

若用static const修饰，编译器可能将其优化到代码段（不可修改）。

7.3 多线程程序的栈

每个线程有独立的栈（避免线程间数据干扰），但共享堆、数据段、代码段。因此，多线程程序中局部变量是线程安全的，而全局变量需要加锁保护。

7.4 嵌入式系统的内存布局

嵌入式系统资源有限（如只有几十 KB 内存），内存布局可能更紧凑（甚至代码段和数据段重叠）。此时需要严格控制全局变量和堆的使用，避免栈溢出。

8. 总结：内存布局是 C 语言的 “骨骼”

理解内存布局（栈、堆、数据段、代码段）是 C 语言编程的核心能力。它能帮助你：

避免内存错误（如栈溢出、内存泄漏）；
优化内存使用（如用局部变量替代全局变量，减少堆分配）；
调试复杂问题（如通过地址判断变量所在段，定位错误）。

用 “餐厅比喻” 理解内存布局

咱们把计算机的内存想象成一家超大型餐厅，里面有四个 “功能区”，分别对应 C 语言的栈、堆、数据段、代码段。你可以把写程序比作在餐厅里招待客人，不同的 “物品”（变量、代码）要放在不同的区域，方便管理。

1. 栈（Stack）：临时餐盘区 —— 用完就收

特点：像餐厅里叠放的餐盘，每次用新餐盘只能从最上面拿（后进先出），用完的餐盘也必须放回最上面。
对应 C 语言：函数里的局部变量（比如你在main()里定义的int a=10）就存这里。
为什么？
当你调用一个函数（比如void eat()），就像餐厅来了一桌客人，需要临时拿几个餐盘（局部变量）。客人吃完（函数执行完），餐盘必须立刻收走（局部变量被销毁），腾出位置给下一桌。
关键记忆点：

自动分配 / 释放，不用你操心（编译器管）。
空间小（像餐盘数量有限），不能存太大的东西（比如定义int arr[1000000]可能 “压垮” 栈，导致崩溃）。

2. 堆（Heap）：自助取餐区 —— 自己占位置

特点：像餐厅的自助区，没有固定位置，你得自己找地方放东西（甚至可以 “占” 一大片），用完后要自己收拾（不然地方会被占满）。
对应 C 语言：用malloc()/calloc()动态申请的内存（比如int* p = malloc(10*sizeof(int))）就存这里。
为什么？
如果你需要存的数据大小不确定（比如用户输入的数组长度），或者需要跨函数使用（比如在 A 函数申请，B 函数用），栈的 “临时餐盘” 不够用，就得去堆区 “占位置”。
关键记忆点：

手动分配 / 释放（你得自己用free()收拾，不然会 “内存泄漏”，餐厅越来越挤）。
空间大（像自助区可以扩展），但管理麻烦（可能出现 “碎片”，比如中间有空位但没法放太大的东西）。

3. 数据段（Data Segment）：仓库 —— 长期存放

特点：像餐厅的仓库，专门放长期需要的食材（比如盐、糖、油），不管有没有客人，这些东西都得一直备着。
对应 C 语言：全局变量（比如int global_num=100;）和静态变量（比如static int static_num=200;）存这里。
为什么？
全局变量从程序启动到结束都要存在（比如记录程序运行次数），静态变量虽然只能在一个函数里用，但也需要 “活” 到程序结束（比如函数里的static int count=0，每次调用都会保留上次的值）。
关键记忆点：

分两小类：
- .data段：存已初始化的全局 / 静态变量（比如int a=10）。
- .bss段：存未初始化的全局 / 静态变量（比如int b;，默认值是 0，且不占可执行文件空间）。

4. 代码段（Text Segment）：菜单 —— 只读且固定

特点：像餐厅的菜单，上面写好了做菜的步骤（“煎蛋要先倒油”“炒饭要翻炒 3 分钟”）。菜单一旦印好就不能改（改了会被客人投诉），而且所有厨师（CPU）都按菜单操作。
对应 C 语言：程序的代码（比如printf("hello");）和常量（比如"hello"字符串、3.14这样的数字）存这里。
为什么？
代码是程序的 “操作指令”，必须保证安全（不能被意外修改），所以代码段是只读且可执行的。常量（比如char* str="hello"中的"hello"）也存在这里，因为它们不能被修改（改了会报 “段错误”）。

总结表格（一图胜千言）

内存区域	类比餐厅	存储内容	管理方式	关键特点
代码段	菜单	代码指令、常量（如 "hello"）	编译器生成，只读	不能改，程序运行的 “操作手册”
数据段	仓库	全局变量、静态变量（已初始化 /.data；未初始化 /.bss）	程序启动时分配，结束时释放	长期存在，占内存
栈	临时餐盘区	局部变量、函数参数、返回地址	函数调用时自动压栈，结束时弹栈	空间小，速度快，后进先出
堆	自助取餐区	动态分配的内存（malloc/calloc）	手动分配（malloc）、手动释放（free）	空间大，灵活，但易泄漏