1一句话 + 关键问题

第 13 章从 OS 的角度定义了地址空间；这一章换到程序员的角度：在自己的地址空间里，怎样用 malloc() / free() 申请和归还内存，以及最常见的七种错误。原书说这一章"短而尖锐"。

它承上启下：你会看到 malloc 必须自己记住每块的大小（第 17 章会揭晓它把大小藏在头块（header）里），也会看到 malloc 不是系统调用，而是建立在 brk/sbrk/mmap 之上的库。

2核心概念速览

3图解：两种内存与 malloc/free

3.1 栈 vs. 堆

运行 C 程序时有两种内存。栈内存的分配和释放由编译器替你完成：

void func() {
    int x;          // 在栈上声明一个整数
    ...
}                   // 返回时编译器自动回收 x

调用 func() 时编译器在栈上腾出空间，返回时收回。所以想让信息活得比这次调用更久，就不能放在栈上。这种对长寿内存的需求引出了堆内存，分配和释放完全由你显式负责：

void func() {
    int *x = (int *) malloc(sizeof(int));
    ...
}

注意这一行里栈分配和堆分配同时发生：编译器看到 int *x 就在栈上给指针留位置；程序调用 malloc() 在堆上申请一个整数的空间，返回它的地址（失败则返回 NULL），这个地址再存到栈上的 x 里。

3.2 malloc()：告诉它你要几个字节

#include <stdlib.h>
void *malloc(size_t size);

包含 stdlib.h 其实不是必需的（malloc 的代码就在所有 C 程序默认链接的 C 库里），它只是让编译器检查你调用得对不对。参数 size_t size 就是需要的字节数。手写数字（如 10）被认为是糟糕的风格，应该用 sizeof：

double *d = (double *) malloc(sizeof(double));   // sizeof(double) 在编译期就是 8

sizeof() 是编译期运算符，不是函数调用。但对变量用 sizeof 要小心：

malloc 返回 void *——C 里就是这样把一个地址交还给你，由你决定怎么用。书里的 (double *) 这种强制类型转换（cast）对正确性毫无作用，只是告诉编译器和读代码的人"我知道我在做什么"。

3.3 free()：只给指针，不给大小

int *x = malloc(10 * sizeof(int));
...
free(x);

分配是容易的部分；何时、如何、甚至是否要释放才是难点。free() 只接受一个参数：之前 malloc() 返回的指针。你会注意到用户并没有传入大小——这意味着内存分配库必须自己记住每块有多大。

3.4 七种常见错误（每种一张图）

下面这些错误原书作者在本科 OS 课上"一遍又一遍"地见到。它们全部能编译通过、跑起来也可能毫无动静——编译通过是写出正确 C 程序的必要条件，但远远不够。正因为内存管理太容易出错，许多新语言提供了自动内存管理：你 new 对象，但从不需要释放，由垃圾回收器（garbage collector）找出不再被引用的内存替你释放。

下面每张图都是用第 4 节的"堆操作沙盒"跑出来的出错那一刻：上方是栈上的变量，下方是堆（每格代表一个单元），红框是出事的位置。

① 忘记分配内存（forgetting to allocate memory）

char *src = "hello";
char *dst;              // oops! unallocated
strcpy(dst, src);       // segfault and die

段错误（segmentation fault）是"你在内存上干了蠢事，我很生气"的花哨说法（第 16 章会解释这个名字的来历）。正确写法是 char *dst = (char *) malloc(strlen(src) + 1);，或者直接用 strdup()。

② 分配不足（not allocating enough memory）= 缓冲区溢出（buffer overflow）

char *src = "hello";
char *dst = (char *) malloc(strlen(src));   // too small!  少了 '\0' 那 1 个字节
strcpy(dst, src);

奇怪的是，这种程序常常看起来运行正确：多写的 1 字节有时无害（覆盖了一个没人再用的变量），有时 malloc 本来就多给了一点空间；但有时它极其有害，许多安全漏洞正源于此；还有时程序直接崩溃。教训：跑对过一次，不代表它是对的。

③ 忘记初始化分配的内存（forgetting to initialize allocated memory）

运气好读到 0 之类让程序照常工作的值，运气不好就是随机而有害的东西。calloc() 在返回前会把内存清零，可以防止"以为内存是 0"这类错误。

④ 忘记释放内存（forgetting to free memory）= 内存泄漏（memory leak）

在长期运行的程序或系统（比如 OS 本身）里这是大问题：内存慢慢漏光，只能重启。注意垃圾回收语言也救不了你：只要你还持有某块内存的引用，GC 就永远不会释放它。

⑤ 用完之前就释放（freeing memory before you are done with it）= 悬挂指针（dangling pointer）

后续使用可能让程序崩溃，也可能覆盖有效内存——比如你 free 之后又 malloc 了别的东西，分配器恰好回收利用了这块被错误释放的内存。

⑥ 重复释放（freeing memory repeatedly）= double free

⑦ 错误地调用 free（calling free() incorrectly）= invalid free

内存错误如此常见，于是有了一整套工具生态：purify 和 valgrind 都能帮你定位内存问题的源头；本机实验用的是 gcc 自带的 AddressSanitizer（-fsanitize=address）。用惯了之后，你会奇怪以前没有它们是怎么活下来的。

3.5 底层 OS 支持：brk、sbrk、mmap

你可能注意到了：讲 malloc/free 时一直没提系统调用。原因很简单：它们不是系统调用，而是库调用。malloc 库在你的虚拟地址空间里管理空间，而它本身建立在几个向 OS 要内存/还内存的系统调用之上：

3.6 其他调用：calloc 和 realloc

• calloc()：分配内存并在返回前清零，避免"以为内存是零"却忘了初始化的错误。
• realloc()：已经分配了一块（比如数组），需要更多空间时用：它分配一块更大的新区域、把旧内容拷过去、返回新指针。旧指针随之失效——继续用它就是悬挂指针。

4模拟器：堆操作沙盒

5先预测，再验证

6动手实验：用工具抓出内存错误

cd labs/14-memory-api && make
./overflow ; echo "exit=$?"        # 普通版：看起来没事
./overflow-asan                     # ASan 版：当场抓住
make run                            # 依次运行全部 18 个版本

下表是本机（gcc 14，WSL2）的真实结果。示例输出，你的机器上地址会不同：

几段关键输出。分配不足（too_small.c）：普通版一切正常，ASan 版：

$ ./too_small
dst = hello
$ ./too_small-asan
==345305==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x502000000015 ...
WRITE of size 6 at 0x502000000015 thread T0
    #0 0x74982fea2680 in strcpy ../../../../src/libsanitizer/asan/asan_interceptors.cpp:563
    #1 0x5ad467a921f6 in main too_small.c:8
0x502000000015 is located 0 bytes after 5-byte region [0x502000000010,0x502000000015)
allocated by thread T0 here:
    #1 0x5ad467a921df in main too_small.c:7

ASan 精确地告诉你：第 8 行的 strcpy 往一个 5 字节的块写了 6 字节，块是第 7 行分配的。悬挂指针（dangling.c）：

$ ./dangling
data=0x5b597e93a2a0 other=0x5b597e93a2a0 data[5]=12345
$ ./dangling-asan
==345319==ERROR: AddressSanitizer: heap-use-after-free on address 0x514000000054 ...
READ of size 4 at 0x514000000054 thread T0
    #0 0x563a582c02d0 in main dangling.c:10
0x514000000054 is located 20 bytes inside of 400-byte region [0x514000000040,0x5140000001d0)
freed by thread T0 here:
    #1 0x563a582c023e in main dangling.c:7
previously allocated by thread T0 here:
    #1 0x563a582c01ca in main dangling.c:5

普通版里 data 和 other 是同一个地址：free 掉的内存马上被下一次 malloc 回收，通过旧指针读到了新主人写的 12345。内存泄漏（leak.c）：

$ ./leak-asan
exiting without free

=================================================================
==345315==ERROR: LeakSanitizer: detected memory leaks

Direct leak of 3072 byte(s) in 3 object(s) allocated from:
    #0 0x7b83eb8f4c57 in malloc ../../../../src/libsanitizer/asan/asan_malloc_linux.cpp:69
    #1 0x6149649971b3 in main leak.c:7

SUMMARY: AddressSanitizer: 3072 byte(s) leaked in 3 allocation(s).

重复释放：glibc 自己就有检查，不用工具也会中止：

$ ./double_free
freed once, freeing again...
free(): double free detected in tcache 2
Aborted                    (退出码 134 = 128 + SIGABRT)

7自测题

8常见误区与小结