C 语言动态内存管理：从申请空间到安全释放

在 C 语言中，数组大小通常需要在编译时确定。但很多程序只有在运行过程中，才能知道真正需要处理多少条数据。例如，读取一份记录数量不固定的文件、维护不断增长的列表，或者根据用户输入创建缓冲区。此时，固定长度数组要么浪费空间，要么无法容纳全部数据。

动态内存管理让程序可以在运行时向堆区申请空间，并在不再使用时主动归还。它提供了更大的灵活性，同时也把内存生命周期交给了程序员：申请是否成功、何时释放、指针是否仍然有效，都需要由代码明确保证。

一、动态内存的基本生命周期

一块动态内存通常经历以下过程：

根据元素数量计算字节数。
调用分配函数申请空间。
检查返回值，确认申请成功。
在有效范围内读写数据。
使用结束后调用 free 释放。
将指针置为 NULL，避免后续误用旧地址。

可以把这套流程理解为"谁申请，谁负责释放"。如果一个函数把内存所有权交给调用者，就应当明确说明由谁负责最终释放；如果所有权没有被清楚地传递，内存泄漏和重复释放就很容易发生。

二、`malloc`：申请未初始化空间

malloc 按字节数申请一段连续空间，函数原型如下：

c 复制代码

void *malloc(size_t size);

返回值是一个 void *，可以赋给任意对象指针。申请数组时，推荐使用元素个数乘以单个元素大小，并让 sizeof 根据指针所指类型自动推导：

c 复制代码

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

int main(void)
{
    size_t count = 10;
    int *values = malloc(count * sizeof *values);

    if (values == NULL) {
        puts("memory allocation failed");
        return 1;
    }

    for (size_t i = 0; i < count; ++i) {
        values[i] = (int)i;
    }

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

malloc 只负责提供空间，不会自动清零。新申请的区域可能包含任意旧数据，因此必须先写入，再读取。不要把"看起来像 0"的内容当成初始化结果。

返回 NULL 表示申请失败。失败原因可能是请求空间过大、系统可用内存不足，或者运行环境无法满足请求。任何使用动态内存的代码都应该在解引用前检查返回值。

当 size 为 0 时，具体行为由实现决定，程序不应依赖这次调用返回的指针。计算申请大小时还要注意整数溢出，例如 count * sizeof *values 溢出后会得到一个过小的数，随后写入数组就可能越界。

三、`free`：释放空间并管理指针状态

使用完动态空间后，通过 free 将它归还给系统：

c 复制代码

free(values);
values = NULL;

free 只能接收动态内存分配函数返回的起始地址，或者 NULL。传入 NULL 不会产生任何效果，所以把指针置空后再次调用 free 是安全的。

释放内存并不等于变量本身消失。指针变量仍然存在，但其中保存的地址已经失效。释放后将指针设为 NULL，可以让后续的状态判断更清晰，也能降低重复释放的风险。不过，置空只能避免一部分错误，不能修复已经发生的越界写入或其他悬空指针。

四、`calloc`：申请并清零

当程序需要一组初始值为零的元素时，可以使用 calloc：

c 复制代码

void *calloc(size_t num, size_t size);

它按照 num 个、每个 size 字节的方式申请连续空间，并将这段空间按字节清零：

c 复制代码

size_t count = 8;
int *scores = calloc(count, sizeof *scores);
if (scores == NULL) {
    return 1;
}

/* scores[0] 到 scores[7] 的字节都已被清零 */
free(scores);
scores = NULL;

对于整数类型，字节全为零通常得到数值 0；但"按字节清零"和"对任意类型调用某种初始化函数"不是同一个概念。使用结构体、浮点数或指针时，应根据实际类型语义判断是否适合依赖这种初始化方式。

五、`realloc`：调整已分配空间

realloc 用来改变一块动态内存的大小：

c 复制代码

void *realloc(void *ptr, size_t size);

当需要扩容时，运行库可能直接在原位置扩大空间，也可能申请一块新空间，复制旧数据，再释放原来的空间。因此，扩容成功后，旧指针可能已经失效；调用者只能使用 realloc 返回的新地址。

最重要的写法是使用临时指针接收结果：

c 复制代码

size_t new_count = 20;
int *tmp = realloc(values, new_count * sizeof *values);
if (tmp != NULL) {
    values = tmp;
    count = new_count;
} else {
    /* 原来的 values 仍然有效，可以继续处理或稍后释放 */
}

不要直接写成 values = realloc(values, new_size)。如果扩容失败，realloc 返回 NULL，原地址就会丢失，既无法继续使用原数据，也无法正确释放原空间。

还要注意几种边界情况：

realloc(NULL, size) 等价于一次新的分配。
新大小小于旧大小时，尾部数据会被截断。
新增加的区域不会自动初始化。
调用成功后，原来的指针不能再作为有效地址使用。
传给 realloc 的地址必须是动态分配得到的起始地址，或者 NULL。

六、动态内存中的典型错误

1. 解引用空指针

分配失败后仍然写入 ptr[0] 或 *ptr，会访问无效地址。正确顺序是先判断，再使用：

c 复制代码

int *ptr = malloc(sizeof *ptr);
if (ptr == NULL) {
    /* 处理失败 */
} else {
    *ptr = 42;
}

2. 数组越界

申请了 count 个元素时，合法下标是 0 到 count - 1。下标计算错误、循环条件写成 i <= count，或者扩容后的数量没有同步更新，都可能导致越界读写。越界写入不仅会破坏相邻数据，也可能破坏分配器自身的管理信息，最终在无关位置崩溃。

3. 释放非动态内存

栈数组、全局数组和字符串字面量并不是通过 malloc、calloc 或 realloc 得到的，不能传给 free：

c 复制代码

int local[4];
/* free(local); 这是错误的 */

4. 释放偏移后的地址

如果 ptr 指向一块动态空间的起始位置，那么 ptr + 1 指向的是内部元素，不能释放：

c 复制代码

int *ptr = malloc(4 * sizeof *ptr);
if (ptr != NULL) {
    int *middle = ptr + 1;
    /* free(middle); 这是错误的 */
    free(ptr);
    ptr = NULL;
}

5. 重复释放

同一块空间只能释放一次。释放后立即置 NULL，并在不同函数之间明确谁拥有释放责任，可以减少重复释放。

6. 释放后继续使用

释放后的指针称为悬空指针。即使它的数值看起来没有变化，也不能继续读写：

c 复制代码

free(ptr);
ptr = NULL;

把指针置空只能让错误更早暴露，不能让原来的数据重新有效。

7. 内存泄漏

如果程序丢失了动态空间的唯一地址，却没有调用 free，这块空间在进程结束前都无法再次使用。循环中不断申请、异常分支提前返回、覆盖旧指针以及函数接口没有约定所有权，都是常见的泄漏来源。

七、在函数中申请内存：为什么需要二级指针

C 语言的参数默认按值传递。把一个指针传给函数时，函数拿到的是指针值的副本。函数内给这个副本赋新地址，不会改变调用者的指针：

c 复制代码

void allocate_wrong(char *out, size_t size)
{
    out = malloc(size);
}

如果函数需要修改调用者的指针，就要传入指针的地址，也就是二级指针：

c 复制代码

#include <stddef.h>
#include <stdlib.h>

int allocate_buffer(char **out, size_t size)
{
    if (out == NULL) {
        return 0;
    }

    *out = malloc(size);
    return *out != NULL;
}

int main(void)
{
    char *buffer = NULL;
    if (!allocate_buffer(&buffer, 128)) {
        return 1;
    }

    /* 使用 buffer */
    free(buffer);
    buffer = NULL;
    return 0;
}

这类接口还应该明确失败时的状态。例如，函数开始时可以要求 *out 为 NULL，或在分配失败时保证它不会指向一块未知空间。释放责任也应写进接口约定：调用者成功获得地址后，通常由调用者负责 free。

八、不要返回局部数组的地址

函数结束时，局部变量所在的栈帧会失效。返回局部数组地址会得到悬空指针：

c 复制代码

int *make_values(void)
{
    int values[3] = {1, 2, 3};
    return values; /* 错误：函数返回后 values 已失效 */
}

如果调用者需要在函数结束后继续使用数据，可以让调用者提供数组，或者在堆上申请空间并把所有权交给调用者：

c 复制代码

int *make_values(void)
{
    int *values = malloc(3 * sizeof *values);
    if (values == NULL) {
        return NULL;
    }

    values[0] = 1;
    values[1] = 2;
    values[2] = 3;
    return values;
}

使用上面的函数后，调用者必须负责 free 返回的地址。另一种更清晰的方式是让函数接收输出数组和容量，由调用者统一管理存储空间。

九、程序中的主要内存区域

理解不同存储区域，有助于判断对象的生命周期和释放方式：

栈区：保存函数参数、局部变量等，函数返回后相关空间通常失效，由系统自动管理，不能使用 free。
堆区：由 malloc、calloc、realloc 等函数动态申请，必须由程序显式释放。
静态存储区：保存全局变量、静态变量等，对象的生命周期通常贯穿整个程序运行过程，不应手动释放。
代码区：保存程序指令，通常具有只读属性，不能当作普通数据空间写入。

一个指针变量本身可能在栈区，但它指向的数组却在堆区。判断能否调用 free，要看指针所保存的目标地址是如何获得的，而不是只看指针变量位于哪个区域。

十、柔性数组成员：结构体和动态空间的连续组合

柔性数组成员是结构体最后一个成员，写成不指定长度的数组：

c 复制代码

#include <stddef.h>
#include <stdlib.h>

typedef struct {
    size_t count;
    int values[];
} IntBuffer;

柔性数组本身不计入结构体的固定大小，sizeof(IntBuffer) 只包含 count 等固定成员。创建对象时，需要一次性为结构体和数组元素申请连续空间：

c 复制代码

size_t count = 5;
IntBuffer *buffer = malloc(sizeof *buffer + count * sizeof buffer->values[0]);
if (buffer == NULL) {
    return 1;
}

buffer->count = count;
for (size_t i = 0; i < count; ++i) {
    buffer->values[i] = (int)i;
}

free(buffer);
buffer = NULL;

这种布局的优点是结构体和数据连续存放，只需要一次申请和一次释放，访问时也具有较好的局部性。柔性数组必须位于结构体末尾，结构体不能直接用普通的按值初始化方式为它预留空间。计算总大小时，要注意乘法溢出，并确保元素数量与实际申请的空间保持一致。

如果结构体中改用 int *values，就需要分别申请结构体和数组，并分别释放；柔性数组则把两者合并成一块动态对象，所有权关系更简单。

十一、动态数组的扩容策略

频繁地每次只增加一个元素，会导致大量的内存申请和数据复制。更实用的做法是维护"有效数量"和"容量"两个值：

c 复制代码

typedef struct {
    int *data;
    size_t size;
    size_t capacity;
} IntVector;

当 size == capacity 时，一次性把容量扩大，例如扩大到原来的两倍。扩容时仍然使用临时指针：

c 复制代码

size_t new_capacity = vector->capacity == 0
                    ? 4
                    : vector->capacity * 2;
int *tmp = realloc(vector->data,
                   new_capacity * sizeof *vector->data);
if (tmp == NULL) {
    /* 原数据保持不变 */
    return 0;
}

vector->data = tmp;
vector->capacity = new_capacity;
return 1;

容量增长减少了平均扩容次数，但仍要检查容量计算是否溢出。释放动态数组时，先释放 data，再将指针和容量重置为安全状态。

十二、使用动态内存前后的检查清单

写完相关代码后，可以逐项检查：

申请字节数是否正确，乘法是否可能溢出？
malloc、calloc、realloc 的返回值是否经过检查？
malloc 得到的空间是否在读取前完成初始化？
每个下标是否都处于合法范围？
realloc 是否使用临时指针接收结果？
传给 free 的是否是动态空间的起始地址？
是否存在重复释放、释放后使用或内存泄漏？
函数是否清楚说明了内存的创建者和释放者？
是否错误地返回了局部变量或局部数组的地址？
柔性数组的总大小和元素数量是否保持一致？

在调试阶段，还可以使用编译器的地址检查工具、运行时检测工具以及更严格的编译警告，尽早发现越界、泄漏和 use-after-free 等问题。工具不能替代生命周期设计，但能显著缩短定位错误的时间。

总结

动态内存让 C 语言能够处理大小不确定、生命周期灵活的数据。malloc 申请未初始化空间，calloc 申请并清零，realloc 调整已有空间，free 结束这段空间的生命周期。真正困难的部分不在于记住函数原型，而在于持续维护指针的有效性、边界和所有权。

只要坚持"申请后检查、使用前初始化、访问不越界、释放起始地址、释放后不再使用、失败路径也要清理"的原则，并通过二级指针和柔性数组设计清晰的接口，动态内存就能从容易出错的底层操作，变成可靠的数据管理工具。

C 语言动态内存管理：从申请空间到安全释放