C程序内存布局详解

1. 内存布局概述

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

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

2. 各区域详解

2.1 代码段（Text Segment）

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

示例：

c 复制代码

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

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

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

示例：

c 复制代码

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

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

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

示例：

c 复制代码

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

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

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

示例：

c 复制代码

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

2.5 堆（Heap）

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

示例：

c 复制代码

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查看）。
生命周期：函数调用期间。

示例：

c 复制代码

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段（根据是否初始化）：

c 复制代码

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

4.2 指针与内存区域

指针变量本身存储在：

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

4.3 常见错误

栈溢出（Stack Overflow） ：

c 复制代码

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

堆内存泄漏（Memory Leak） ：

c 复制代码

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

野指针（Dangling Pointer） ：

c 复制代码

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

重复释放（Double Free） ：

c 复制代码

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

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

c 复制代码

#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;   // .data
    static int static_uninit;      // .bss
    int 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;
}

运行此程序可以观察到各变量的地址分布，验证内存布局。

6. 总结

理解C程序内存布局对于：

避免内存错误（泄漏、越界、野指针）
优化程序性能（缓存友好性）
理解程序运行机制
至关重要。务必掌握各区域的特点及生命周期，并在编程中谨慎处理动态内存和指针。