C程序内存布局详解

1. 内存布局概述

C程序在内存中分为以下几个主要区域（从低地址到高地址）：

代码段（.text）
只读数据段（.rodata）
初始化数据段（.data）
未初始化数据段（.bss）
堆（Heap）
栈（Stack）
内核空间（Kernel space）（用户程序不可访问）
注意：堆和栈之间是未分配的内存空间，两者相向生长。

2. 各区域详解

2.1 代码段（Text Segment）

存储内容：程序的可执行指令（机器代码）。
特点：只读、固定大小。
生命周期：程序整个运行期间。

示例：

int main() {return 0;   // main函数的指令存储在此
}

2.2 只读数据段（Read-Only Data Segment）

存储内容：字符串常量、const修饰的全局变量。
特点：只读，任何修改操作会导致段错误（Segmentation Fault）。
生命周期：程序整个运行期间。

示例：

const int max = 100;   // 存储于.rodata
char *str = "hello";   // 字符串字面量"hello"存储于.rodata
void foo() {// 错误示例：尝试修改只读数据// str[0] = 'H';   // 运行时错误：段错误
}

2.3 初始化数据段（Initialized Data Segment）

存储内容：已初始化的全局变量和静态变量（非零初始化）。
特点：可读写，程序加载时从可执行文件中读取初始值。
生命周期：程序整个运行期间。

示例：

int global_init = 42;           // 存储于.data
static int static_init = 10;    // 存储于.data
int main() {// ...
}

2.4 未初始化数据段（Uninitialized Data Segment / .bss）

存储内容：未初始化或初始化为0的全局变量和静态变量。
特点：可读写，程序加载时由系统初始化为0。
生命周期：程序整个运行期间。

示例：

int global_uninit;         // 存储于.bss，初始化为0
static int static_uninit;  // 存储于.bss，初始化为0
int main() {// ...
}

2.5 堆（Heap）

存储内容：动态分配的内存。
特点：
- 手动管理（通过malloc、calloc、realloc分配，free释放）。
- 从低地址向高地址增长。
- 分配速度相对较慢。
生命周期：从分配成功到显式释放。

示例：

int main() {int *arr = (int*)malloc(10 * sizeof(int));  // 在堆上分配if (arr) {arr[0] = 1;   // 合法访问free(arr);    // 显式释放}return 0;
}

2.6 栈（Stack）

存储内容：
- 函数调用时的返回地址
- 函数参数
- 局部变量（非静态）
- 函数调用的上下文
特点：
- 由编译器自动管理（入栈/出栈）。
- 从高地址向低地址增长。
- 分配速度快。
- 大小有限（Linux默认约8MB，可通过ulimit -s查看）。
生命周期：函数调用期间。

示例：

void func(int param) {   // 参数param在栈上int local_var = 10;  // 局部变量在栈上// ...
}   // 函数结束时，param和local_var自动释放
int main() {func(5);return 0;
}

3. 内存布局图示

高地址
+-----------------------+
|       内核空间         |
+-----------------------+
|         栈            | <- 由高地址向低地址增长
| (局部变量、函数参数等)  |
+-----------------------+
|          ...          |
+-----------------------+
|         堆            | <- 由低地址向高地址增长
|   (动态分配的内存)     |
+-----------------------+
|         .bss          | (未初始化全局/静态变量)
+-----------------------+
|         .data         | (已初始化全局/静态变量)
+-----------------------+
|        .rodata        | (只读数据)
+-----------------------+
|         .text         | (程序代码)
低地址

在这里插入图片描述

空洞地址（Hole Address）通常指虚拟地址空间中未被映射到任何物理内存或存储介质（如磁盘交换区）的地址范围。这些地址属于进程可见的虚拟地址空间，但由于未被操作系统分配或关联到实际的物理资源，无法被进程正常访问。

核心特点：
1，未映射性：空洞地址没有对应的物理内存页或磁盘块，操作系统的内存管理单元（MMU）无法将其转换为物理地址。
2，访问受限：进程若尝试读取或写入空洞地址，会触发内存访问错误（如 Linux 中的SIGSEGV信号），导致进程终止（俗称 “段错误”）。
3，存在的合理性：,空洞地址并非 “浪费”，而是操作系统设计中用于隔离内存区域的常见手段。例如：
（1）进程的代码段、数据段、堆、栈等区域之间通常存在空洞，防止不同区域的越界访问相互干扰；
（2）32 位系统中，用户空间与内核空间之间可能保留大量未映射的地址作为隔离带；
（3）动态内存分配（如malloc）后，堆的增长可能与栈的扩展之间形成临时空洞。

4. 关键注意事项

4.1 静态局部变量的存储位置

静态局部变量虽然作用域在函数内，但存储在.data或.bss段（根据是否初始化）：

void counter() {static int count = 0;  // 存储在.data（因为初始化了）count++;
}

4.2 指针与内存区域

指针变量本身存储在：

全局指针：.data或.bss
静态指针：.data或.bss
局部指针：栈上
动态分配指针：堆上（指针变量在栈，指向的内容在堆）

4.3 常见错误

栈溢出（Stack Overflow）：

void recursion() {int arr[10000];  // 大数组占用栈空间recursion();     // 无限递归
}

堆内存泄漏（Memory Leak）：

void leak() {malloc(100);   // 分配后未释放，且丢失了指针
}

野指针（Dangling Pointer）：

int* dang() {int local = 10;return &local;   // 返回局部变量地址（函数结束即失效）
}

重复释放（Double Free）：

int *p = malloc(sizeof(int));
free(p);
free(p);   // 错误：重复释放

5. 验证内存布局的示例程序

#include <stdio.h>
#include <stdlib.h>
const int const_global = 10;      // .rodata
int init_global = 20;             // .data
int uninit_global;                // .bss
int main() {static int static_init = 30;   // .datastatic int static_uninit;      // .bssint local_var;                 // 栈int *heap_var = malloc(10);    // 堆printf("代码段(.text):   %p\n", main);printf("只读段(.rodata): %p\n", &const_global);printf("数据段(.data):   %p (init_global)\n", &init_global);printf("数据段(.data):   %p (static_init)\n", &static_init);printf("BSS段(.bss):     %p (uninit_global)\n", &uninit_global);printf("BSS段(.bss):     %p (static_uninit)\n", &static_uninit);printf("堆(Heap):        %p\n", heap_var);printf("栈(Stack):       %p\n", &local_var);free(heap_var);return 0;
}