前言
前几篇我们聊了指针、内存池，但你有没有想过一个问题：当我们写下一行 int a = 10;，这个 a 到底住在内存的哪个角落？为什么局部变量和全局变量的“寿命”不一样？malloc 出来的内存又在哪里？
理解C语言的内存布局，是写出高质量代码的必经之路。今天，我们用一张全景图，把程序的“住所”彻底讲清楚。
一、程序在内存中的五个区域
当一个C程序运行起来，操作系统会为它分配一块虚拟内存，这块内存被划分为五个区域：
```
高地址
┌─────────────────┐
│ 栈段 │ ← 局部变量、函数调用
├─────────────────┤
│ ↓ │
│ 空闲区 │
│ ↑ │
├─────────────────┤
│ 堆段 │ ← malloc/new 分配
├─────────────────┤
│ BSS段 │ ← 未初始化的全局/静态变量
├─────────────────┤
│ 数据段 │ ← 已初始化的全局/静态变量
├─────────────────┤
│ 代码段 │ ← 函数指令、常量
└─────────────────┘
低地址 (0x400000)
```
1. 代码段（Text Segment）
· 存放内容：编译后的机器指令、只读常量（字符串字面量）
· 权限：只读，防止程序意外修改自己的指令
· 生命周期：整个程序运行期间
```c
char *s = "hello"; // "hello" 在代码段，不可修改
*s = 'H'; // 错误！段错误
```
2. 数据段（Data Segment）
· 存放内容：已初始化的全局变量和静态变量
· 权限：可读写
· 生命周期：程序启动到结束
```c
int global = 100; // 数据段
static int counter = 0; // 数据段
```
3. BSS段（Block Started by Symbol）
· 存放内容：未初始化的全局变量和静态变量
· 特殊之处：程序启动时会被自动清零
· 节省空间：只记录大小和位置，不占用可执行文件空间
```c
int global_uninit; // BSS段，初始值为0
static int counter; // BSS段，初始值为0
```
4. 堆段（Heap）
· 存放内容：动态分配的内存（malloc/calloc/realloc）
· 管理方式：程序员手动管理（申请/释放）
· 特点：从低地址向高地址增长
```c
int *p = (int*)malloc(10 * sizeof(int)); // 堆上分配
free(p); // 手动释放
```
5. 栈段（Stack）
· 存放内容：局部变量、函数参数、返回地址
· 管理方式：编译器自动管理
· 特点：从高地址向低地址增长，后进先出
```c
void func() {
int local = 10; // 栈上分配，函数结束时自动销毁
}
```
二、代码示例：看看变量都住哪儿
```c
#include <stdio.h>
#include <stdlib.h>
int global_init = 42; // 数据段
int global_uninit; // BSS段
static int static_init = 1; // 数据段
static int static_uninit; // BSS段
int main() {
int local = 10; // 栈
static int local_static = 5; // 数据段（局部静态变量）
const int local_const = 20; // 栈（const只是语法限制，不是放代码段）
char *str = "hello"; // str在栈，指向的字符串在代码段
char arr[] = "world"; // arr在栈，数组内容也在栈
int *heap_ptr = (int*)malloc(10 * sizeof(int)); // 指针在栈，指向的内存在堆
heap_ptr[0] = 100;
printf("代码段: %p\n", main);
printf("数据段: %p\n", &global_init);
printf("BSS段: %p\n", &global_uninit);
printf("堆: %p\n", heap_ptr);
printf("栈: %p\n", &local);
free(heap_ptr);
return 0;
}
```
运行输出（地址可能不同，但相对关系一致）：
```
代码段: 0x4005b0 ← 低地址
数据段: 0x601030
BSS段: 0x601040
堆: 0x1e92420 ← 中地址
栈: 0x7ffd5c8e1a9c ← 高地址
```
三、深入理解栈：函数调用的幕后
栈是C语言运行的核心，每次函数调用都会在栈上创建一个栈帧：
```
调用前：
高地址
┌─────────────┐
│ main 的栈帧 │
└─────────────┘
调用 func(10, 20) 后：
高地址
┌─────────────┐
│ main 的栈帧 │
├─────────────┤
│ 参数2 (20) │
├─────────────┤
│ 参数1 (10) │
├─────────────┤
│ 返回地址 │
├─────────────┤
│ 旧的rbp │
├─────────────┤
│ 局部变量 │
└─────────────┘
低地址
```
栈的特点：
· 分配/释放极快（只需移动栈指针）
· 空间有限（默认几MB），递归过深会栈溢出
· 函数返回后，栈帧数据不会立即清除，但会被覆盖
```c
int* dangerous() {
int local = 10;
return &local; // 错误！返回栈变量的地址
} // 函数返回后，local的内存被回收
```
四、深入理解堆：动态内存的核心
堆用于运行时才能确定大小或生命周期的数据：
```c
// 场景1：运行时才知道需要多大空间
int n;
scanf("%d", &n);
int *arr = (int*)malloc(n * sizeof(int));
// 场景2：需要跨函数存活的数据
int* create_array(int size) {
int *arr = (int*)malloc(size * sizeof(int));
return arr; // 正确：堆内存不会因函数返回而释放
}
```
堆 vs 栈对比：
特性 栈 堆
分配速度 极快 较慢
管理方式 自动 手动
大小限制 小（几MB） 大（可达内存上限）
碎片问题 无 有
生命周期 函数内 直到free
五、常见陷阱与调试
陷阱1：栈溢出
```c
void recursion() {
int arr[100000]; // 栈空间不足
recursion(); // 无限递归
}
```
陷阱2：堆内存泄漏
```c
while (1) {
malloc(1024); // 没有free，内存逐渐耗尽
}
```
陷阱3：野指针（返回栈地址）
```c
int* get_ptr() {
int x = 10;
return &x; // 危险！返回后x被销毁
}
```
调试工具推荐
· Valgrind：检测内存泄漏和非法访问
```bash
valgrind --leak-check=full ./program
```
· Address Sanitizer：编译时加入，运行时检测
```bash
gcc -fsanitize=address -g program.c
```
六、一个综合案例：猜猜输出
```c
#include <stdio.h>
#include <stdlib.h>
int a = 1;
static int b = 2;
int c;
static int d;
const int e = 5;
int main() {
int f = 6;
static int g = 7;
static int h;
int *i = (int*)malloc(sizeof(int));
*i = 8;
char *j = "hello";
printf("&a = %p (数据段)\n", &a);
printf("&b = %p (数据段)\n", &b);
printf("&c = %p (BSS段)\n", &c);
printf("&d = %p (BSS段)\n", &d);
printf("&e = %p (代码段/数据段?)\n", &e); // 常量，可能在只读段
printf("&f = %p (栈)\n", &f);
printf("&g = %p (数据段)\n", &g);
printf("&h = %p (BSS段)\n", &h);
printf(" i = %p (堆)\n", i);
printf(" j = %p (栈上的指针指向代码段)\n", j);
printf("\"hello\" = %p (代码段)\n", "hello");
free(i);
return 0;
}
```
结语
理解内存布局，就像是拿到了程序的“房产地图”。知道变量住在哪里，就能解释为什么有些变量“活”得久，有些“死”得快；为什么栈变量不能作为函数返回值；为什么堆内存需要手动释放。
下一篇文章，我们将进入编译链接的世界，看看源文件是如何一步步变成可执行程序的。
下一篇预告：《从源码到程序：C语言编译链接全过程解析》
