内存管理 — 内存段与布局

内存管理是嵌入式 C 语言开发的核心难点。本文聚焦于程序内存布局、内存段的逻辑与物理映射、以及嵌入式内存优化实践。

1 程序内存布局

1.1 内存段的基本概念

C 程序运行时，内存被划分为不同的区域，每个区域存储特定类型的数据：

• 代码段（.text）：存放程序的机器指令，只读
• 只读数据段（.rodata）：存放常量和字符串字面量，只读
• 已初始化数据段（.data）：存放有初始值的全局变量和静态变量
• 未初始化数据段（.bss）：存放未初始化的全局变量和静态变量，自动清零
• 堆（Heap）：动态分配的内存区域，由 malloc/free 管理
• 栈（Stack）：存放局部变量、函数参数和返回地址，自动管理

1.2 各段对比

不同平台的内存布局：

2 内存段验证实验

2.1 示例：查看变量所在的内存段

// 文件名: memory_layout.c
// 功能: 直观展示不同变量落在哪个内存段

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

// ---- 全局变量 ----
int g_init = 42;          // .data 段（已初始化）
int g_uninit;              // .bss 段（未初始化，自动为 0）
const int g_const = 100;   // .rodata 段
const char *g_string="helloworld";
static int s_init = 7;     // .data 段（static 仍是全局存储）
static int s_uninit;       // .bss 段

int main(void) {
    // ---- 局部变量 ----
    int local = 99;                         // 栈
    static int local_static = 55;           // .data 段！不在栈上
    int *heap_ptr = (int *)malloc(sizeof(int)); // 堆
    *heap_ptr = 888;

    printf("====== C 程序内存布局实验 ======\n\n");

    printf("--- 代码段 (.text) ---\n");
    printf("  main 函数地址:         %p\n", (void *)main);

    printf("\n--- 只读数据段 (.rodata) ---\n");
    printf("  g_const 地址:          %p  值=%d\n", (void *)&g_const, g_const);
    printf("  \"helloworld\" 字符串:  %p  (g_string 指向的内容)\n",
           (void *)g_string);

    printf("\n--- 已初始化数据段 (.data) ---\n");
    printf("  g_init 地址:           %p  值=%d\n", (void *)&g_init, g_init);
    printf("  s_init 地址:           %p  值=%d\n", (void *)&s_init, s_init);
    printf("  g_string 指针本身:     %p  (指针变量在 .data)\n",
           (void *)&g_string);
    printf("  local_static 地址:     %p  值=%d\n",
           (void *)&local_static, local_static);

    printf("\n--- 未初始化数据段 (.bss) ---\n");
    printf("  g_uninit 地址:         %p  值=%d (自动清零)\n",
           (void *)&g_uninit, g_uninit);
    printf("  s_uninit 地址:         %p  值=%d (自动清零)\n",
           (void *)&s_uninit, s_uninit);

    printf("\n--- 堆 (Heap) ---\n");
    printf("  heap_ptr 指向:         %p  值=%d\n", (void *)heap_ptr, *heap_ptr);

    printf("\n--- 栈 (Stack) ---\n");
    printf("  local 地址:            %p  值=%d\n", (void *)&local, local);
    printf("  heap_ptr 变量本身地址: %p (指针变量在栈上)\n",
           (void *)&heap_ptr);

    printf("\n====== 地址规律总结 ======\n");
    printf("  .text < .rodata < .data < .bss < Heap <<< Stack\n");
    printf("  低地址 ──────────────────────────────────→ 高地址\n");

    free(heap_ptr);
    heap_ptr = NULL;
    return 0;
}

2.2 编译与运行

# 编译
gcc -g -Wall -o memory_layout memory_layout.c

# 运行
./memory_layout

输出示例：

====== C 程序内存布局实验 ======

--- 代码段 (.text) ---
  main 函数地址:         0x62bcfcb7a1c9

--- 只读数据段 (.rodata) ---
  g_const 地址:          0x62bcfcb7b008  值=100
  "helloworld" 字符串:  0x62bcfcb7b00c  (g_string 指向的内容)

--- 已初始化数据段 (.data) ---
  g_init 地址:           0x62bcfcb7d010  值=42
  s_init 地址:           0x62bcfcb7d014  值=7
  g_string 指针本身:     0x62bcfcb7d020  (指针变量在 .data)
  local_static 地址:     0x62bcfcb7d018  值=55

--- 未初始化数据段 (.bss) ---
  g_uninit 地址:         0x62bcfcb7d02c  值=0 (自动清零)
  s_uninit 地址:         0x62bcfcb7d030  值=0 (自动清零)

--- 堆 (Heap) ---
  heap_ptr 指向:         0x62bd268c42a0  值=888

--- 栈 (Stack) ---
  local 地址:            0x7fffa8d3662c  值=99
  heap_ptr 变量本身地址: 0x7fffa8d36630 (指针变量在栈上)

====== 地址规律总结 ======
  .text < .rodata < .data < .bss < Heap <<< Stack
  低地址 ──────────────────────────────────→ 高地址

运行截图与分析：

2.3 使用 GCC 验证内存段

# 方法1: 查看汇编代码（编译阶段就能看到段划分）
gcc -S memory_layout.c -o memory_layout.s
cat memory_layout.s | grep -E "\.text|\.rodata|\.data|\.bss" -A 2

# 方法2: 查看目标文件的段信息
gcc -c memory_layout.c -o memory_layout.o
size memory_layout.o                    # 查看各段大小
nm memory_layout.o | grep g_init        # 查看符号所在的段

# 方法3: 查看可执行文件
gcc memory_layout.c -o memory_layout
size memory_layout                      # 查看各段大小
nm memory_layout | grep -E "g_init|g_uninit|g_const"  # 查看符号表

汇编文件中的段标记：

.section .rodata        # 只读数据段
.LC0:
    .string "x=%d\n"

.text                   # 代码段
.globl main
main:
    ...

.data                   # 已初始化数据段
g_init:
    .long 42

.bss                    # 未初始化数据段
g_uninit:
    .zero 4

这就是编译器给数据贴的"逻辑标签"！

size 命令输出验证：

   text    data     bss     dec     hex filename
   2345     600      16    2961     b91 memory_layout

• text = 代码段 + 只读数据段
• data = 已初始化的全局/静态变量
• bss = 未初始化的全局/静态变量（不占可执行文件空间）

nm 命令输出验证：

0000000000004010 D g_init       ← D = .data 段
0000000000004018 D g_string     ← D = .data 段（指针变量本身）
000000000000401c B g_uninit     ← B = .bss 段
0000000000002004 R g_const      ← R = .rodata 段（只读）
0000000000002010 r .LC0         ← r = .rodata 段（"helloworld" 字符串）
0000000000004014 d s_init       ← d = .data 段（小写 = 局部符号/static）
0000000000004020 b s_uninit     ← b = .bss 段（小写 = 局部符号/static）

注意 g_string 和 .LC0（字符串字面量）在不同的段：

• g_string 在 .data（地址 0x4018）—— 指针变量
• .LC0 在 .rodata（地址 0x2010）—— 字符串内容

3 自测题