C 程序的内存布局精讲

在C语言中，内存布局是程序运行时非常重要的概念。内存布局直接影响程序的性能、稳定性和安全性。理解C程序的内存布局，有助于编写更高效和可靠的代码。本文将详细介绍C程序的内存布局，包括代码段、数据段、堆、栈等部分，并提供相关的示例和应用。

1. 内存布局概述

当我们创建一个 C 程序并运行该程序时，其可执行文件以有组织的方式存储在计算机的 RAM 中。
C程序的内存布局如下所示：
在这里插入图片描述

从上图中我们可以看出，C 程序由程序中的以下部分组成：

内存区域	描述
代码段（Text/Code Segment）	存储程序的机器指令，只读，多个进程共享
已初始化的数据段（Initialized data segment）	存储初始化的全局变量和静态变量，可读写
未初始化的数据段（Uninitialized data segment）	存储未初始化的全局变量和静态变量，自动初始化为零
堆（Heap）	动态分配的内存区域，需要手动管理内存
栈（Stack）	存储局部变量和函数调用信息，自动分配和释放

每个部分有不同的用途和特点，下面我们将详细介绍每个部分。

2. 代码段（Text/Code Segment）

代码段，也称为文本段，是用来存储程序的机器指令的。这个区域是只读的，防止程序意外地修改其指令。

特点

只读: 防止程序修改指令。
共享: 在多进程环境中，多个进程可以共享同一个代码段，节省内存。

示例

#include <stdio.h>

void hello() {
   
    printf("Hello, World!\n");
}

int main() {
   
    hello();
    return 0;
}

在上面的示例中，hello函数和main函数的代码都存储在代码段中。

3. 已初始化的数据段（Initialized data segment）

数据段用来存储初始化的全局变量和静态变量。这些变量在程序开始时就已经分配了内存，并且在整个程序运行期间保持其值。

特点

初始化: 包含初始化的全局变量和静态变量。
读写: 允许读写操作。

示例

#include <stdio.h>

int global_var = 42;  // 初始化的全局变量

int main() {
   
    static int static_var = 99;  // 初始化的静态变量
    printf("Global: %d, Static: %d\n", global_var, static_var);
    return 0;
}

输出

Global: 42, Static: 99

这个程序中有一个全局变量 global_var 和一个静态变量 static_var，它们分别被初始化为 42 和 99。在 main 函数中，这两个变量的值被打印出来。global_var和static_var都存储在已初始化的数据段中。

4. 未初始化的数据段（Uninitialized data segment）

未初始化的数据段也称为 .bss 段，用于存储所有未初始化的全局变量、局部变量和外部变量。如果未初始化全局变量、静态变量和外部变量，则默认为它们赋值为零。
.bss 段代表 Block Started by symbol。bss 段包含存储所有静态分配变量的目标文件。在这里，静态分配的对象是那些没有显式初始化的对象，初始化为零值。

特点

未初始化: 包含未初始化的全局变量和静态变量。
自动初始化为零: 程序开始时自动将这些变量初始化为零。

示例

#include <stdio.h>

int uninit_global_var;  // 未初始化的全局变量

int main() {
   
    static int uninit_static_var;  // 未初始化的静态变量
    printf("Uninit Global: %d, Uninit Static: %d\n", uninit_global_var, uninit_static_var);
    return 0;
}

输出

Uninit Global: 0, Uninit Static: 0

这个程序中有一个未初始化的全局变量 uninit_global_var 和一个未初始化的静态变量 uninit_static_var。在C语言中，未初始化的全局变量和静态变量会被自动初始化为零。因此，在 main 函数中，这两个变量的值都会是 0。uninit_global_var和uninit_static_var都存储在BSS段中。

5. 堆（Heap）

堆是用来动态分配内存的区域。程序在运行时可以使用malloc、calloc、realloc等函数在堆上分配内存，并在不需要时使用free函数释放内存。

特点

动态分配: 使用malloc、calloc等函数在运行时分配内存。
手动管理: 需要程序员手动管理内存的分配和释放。

示例

#include <stdio.h>
#include <stdlib.h>

int main() {
   
    int *ptr = (int *)malloc(sizeof(int) * 10);  // 在堆上分配内存
    if (ptr == NULL) {
   
        printf("Memory allocation failed\n");
        return 1;
    }
    for (int i = 0; i < 10; i++) {
   
        ptr[i] = i;
    }
    for (int i = 0; i < 10; i++) {
   
        printf("%d ", ptr[i]);
    }
    printf("\n");
    free(ptr);  // 释放内存
    return 0;
}

输出

0 1 2 3 4 5 6 7 8 9

在上面的示例中，使用malloc函数在堆上分配了10个int类型的内存，并在使用后释放了这块内存。然后，它使用一个循环将0到9的整数存储到这个内存块中。接着，程序又使用另一个循环将这些整数打印出来。最后，它释放了之前分配的内存。

6. 栈（Stack）

栈是用来存储局部变量和函数调用信息的区域。栈的内存分配由编译器自动完成，并在函数返回时自动释放。

特点

自动分配和释放: 局部变量和函数调用信息由编译器自动管理。
后进先出: 栈是一种后进先出的数据结构。

示例

#include <stdio.h>

void function() {
   
    int local_var = 10;  // 局部变量，存储在栈中
    printf("Local variable: %d\n", local_var);
}

int main() {
   
    function();
    return 0;
}

输出

Local variable: 10

解释

local_var 是在函数 function 中定义的局部变量，它存储在栈中。
当 function 被调用时，local_var 被分配内存并初始化为 10。
程序通过 printf 函数输出 local_var 的值。
function 执行完毕后，栈帧被释放，local_var 的内存也被回收。

在上面的示例中，local_var存储在栈中，当function函数返回时，这块内存被自动释放。

7. 内存布局示例

下面是详细讲解C程序内存布局的代码示例和其输出显示：

#include <stdio.h>
#include <stdlib.h>

// 数据段
int global_init_var = 100;  // 初始化的全局变量
int global_uninit_var;      // 未初始化的全局变量（BSS段）

void function() {
   
    static int static_var = 200;  // 初始化的静态变量（数据段）
    int local_var = 10;           // 局部变量（栈）
    int *heap_var = (int *)malloc(sizeof(int));  // 动态分配的内存（堆）

    if (heap_var != NULL) {
   
        *heap_var = 300;  // 为堆内存赋值
    }

    // 打印变量值及其地址
    printf("Static: %d, at address: %p\n", static_var, (void*)&static_var);
    printf("Local: %d, at address: %p\n", local_var, (void*)&local_var);
    if (heap_var != NULL) {
   
        printf("Heap: %d, at address: %p\n", *heap_var, (void*)heap_var);
    }

    free(heap_var);  // 释放堆内存
}

int main() {
   
    printf("Global Initialized: %d, at address: %p\n", global_init_var, (void*)&global_init_var);
    printf("Global Uninitialized: %d, at address: %p\n", global_uninit_var, (void*)&global_uninit_var);

    function();

    return 0;
}

代码解释

global_init_var：初始化的全局变量，存储在数据段。
global_uninit_var：未初始化的全局变量，存储在BSS段。
static_var：初始化的静态变量，存储在数据段。
local_var：局部变量，存储在栈中。
heap_var：动态分配的内存，存储在堆中。

输出

运行上述代码，输出将显示每个变量的值和其内存地址：

Global Initialized: 100, at address: 0x561184b1d018
Global Uninitialized: 0, at address: 0x561184b1d01c
Static: 200, at address: 0x561184b1d020
Local: 10, at address: 0x7ffc267b6c9c
Heap: 300, at address: 0x561184b1e2a0

内存布局说明

内存区域	描述	示例变量	示例输出地址
代码段	存储程序的机器指令，只读，多个进程共享	函数代码	不显示
数据段	存储初始化的全局变量和静态变量，可读写	`global_init_var`、`static_var`	`0x561184b1d018`、`0x561184b1d020`
BSS段	存储未初始化的全局变量和静态变量，自动初始化为零	`global_uninit_var`	`0x561184b1d01c`
堆	动态分配的内存区域，需要手动管理内存	`heap_var`	`0x561184b1e2a0`
栈	存储局部变量和函数调用信息，自动分配和释放	`local_var`	`0x7ffc267b6c9c`

详细内存布局解释

代码段：包含函数function和main的机器指令，不在输出中显示地址。
数据段：包含global_init_var和static_var，它们的地址分别为0x561184b1d018和0x561184b1d020。
BSS段：包含global_uninit_var，其地址为0x561184b1d01c。
堆：使用malloc函数动态分配的内存，地址为0x561184b1e2a0。
栈：包含局部变量local_var，其地址为0x7ffc267b6c9c。

通过这些代码和输出示例，可以更直观地理解C语言程序的内存布局。

8. 内存布局在嵌入式系统中的应用

在嵌入式系统中，内存布局的理解和管理尤为重要。嵌入式系统通常具有有限的内存资源，因此需要精细地管理每个内存区域。

示例：嵌入式系统中的内存布局

#include <stdio.h>
#include <stdlib.h>

// 假设这是一个嵌入式系统中的寄存器
typedef struct {
   
    volatile uint32_t CONTROL;
    volatile uint32_t STATUS;
    volatile uint32_t DATA;
} UART_RegDef_t;

int main() {
   
    UART_RegDef_t *UART1 = (UART_RegDef_t *)malloc(sizeof(UART_RegDef_t));  // 堆
    if (UART1 == NULL) {
   
        printf("Memory allocation failed\n");
        return 1;
    }

    // 设置UART寄存器
    UART1->CONTROL = 0x01;  // 启用UART
    UART1->STATUS = 0x00;   // 清除状态
    UART1->DATA = 0x55;     // 发送数据

    // 打印寄存器的配置
    printf("UART1 CONTROL: 0x%X\n", UART1->CONTROL);
    printf("UART1 STATUS: 0x%X\n", UART1->STATUS);
    printf("UART1 DATA: 0x%X\n", UART1->DATA);

    free(UART1);  // 释放堆内存
    return 0;
}

输出

UART1 CONTROL: 0x1
UART1 STATUS: 0x0
UART1 DATA: 0x55

在这个示例中，UART1寄存器存储在堆中，并通过指针进行访问和配置。这种方式在嵌入式系统中非常常见。

9. 内存管理的拓展技巧

9.1 内存泄漏检测

内存泄漏是指程序中未正确释放已分配的内存，导致内存长期得不到释放，从而耗尽系统资源。为了检测和防止内存泄漏，可以使用以下工具和方法：

工具

Valgrind：一个强大的内存调试工具，可以检测内存泄漏、未初始化内存访问和内存越界等问题。
AddressSanitizer：一个内存错误检测工具，集成在Clang和GCC编译器中，能够检测内存泄漏、堆栈溢出和越界访问等问题。
Electric Fence：一个库，用于检测内存分配错误和越界访问。

示例：使用Valgrind检测内存泄漏

#include <stdlib.h>

void memory_leak() {
   
    int *leak = (int *)malloc(sizeof(int) * 10);
    // 未释放内存，导致内存泄漏
}

int main() {
   
    memory_leak();
    return 0;
}

编译并运行：

gcc -g -o memory_leak memory_leak.c
valgrind --leak-check=full ./memory_leak

Valgrind输出：

==12345== HEAP SUMMARY:
==12345==     in use at exit: 40 bytes in 1 blocks
==12345==   total heap usage: 1 allocs, 0 frees, 40 bytes allocated
==12345== 
==12345== LEAK SUMMARY:
==12345==    definitely lost: 40 bytes in 1 blocks
==12345==    indirectly lost: 0 bytes in 0 blocks
==12345==      possibly lost: 0 bytes in 0 blocks
==12345==    still reachable: 0 bytes in 0 blocks
==12345==         suppressed: 0 bytes in 0 blocks
==12345== 
==12345== For counts of detected and suppressed errors, rerun with: -v
==12345== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)

9.2 内存池（Memory Pool）

内存池是一种预分配的内存管理机制，可以提高内存分配和释放的效率，特别适合嵌入式系统和实时系统。

示例：实现简单的内存池

#include <stdio.h>
#include <stdlib.h>

#define POOL_SIZE 1024

typedef struct {
   
    char pool[POOL_SIZE];
    size_t offset;
} MemoryPool;

void pool_init(MemoryPool *mp) {
   
    mp->offset = 0;
}

void *pool_alloc(MemoryPool *mp, size_t size) {
   
    if (mp->offset + size > POOL_SIZE) {
   
        return NULL;  // 内存池不足
    }
    void *ptr = mp->pool + mp->offset;
    mp->offset += size;
    return ptr;
}

void pool_free(MemoryPool *mp) {
   
    mp->offset = 0;  // 重置内存池
}

int main() {
   
    MemoryPool mp;
    pool_init(&mp);

    int *arr = (int *)pool_alloc(&mp, sizeof(int) * 10);
    if (arr == NULL) {
   
        printf("Memory pool allocation failed\n");
        return 1;
    }

    for (int i = 0; i < 10; i++) {
   
        arr[i] = i;
    }

    for (int i = 0; i < 10; i++) {
   
        printf("%d ", arr[i]);
    }
    printf("\n");

    pool_free(&mp);  // 重置内存池
    return 0;
}

输出

0 1 2 3 4 5 6 7 8 9

9.3 智能指针（Smart Pointers）

在C++中，可以使用智能指针（如std::shared_ptr和std::unique_ptr）来自动管理内存，防止内存泄漏。

示例：使用`std::unique_ptr`

#include <iostream>
#include <memory>

void unique_ptr_demo() {
   
    std::unique_ptr<int[]> arr(new int[10]);
    for (int i = 0; i < 10; i++) {
   
        arr[i] = i;
    }
    for (int i = 0; i < 10; i++) {
   
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
}

int main() {
   
    unique_ptr_demo();
    return 0;
}

输出

0 1 2 3 4 5 6 7 8 9

智能指针在超出作用域时会自动释放内存，从而避免内存泄漏。

10. 结束语

本节内容已经全部介绍完毕，希望通过这篇文章，大家对C语言内存布局有了更深入的理解和认识。

感谢各位的阅读和支持，如果觉得这篇文章对你有帮助，请不要吝惜你的点赞和评论，这对我们非常重要。再次感谢大家的关注和支持！

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【C语言】内存布局大揭秘 ! -《堆、栈和你从未听说过的内存角落》