C 语言 malloc：动态内存分配、free 和 sizeof

到目前为止，你写过的每个数组，大小都是在编译时就定死的：int scores[10]; 会预留十个位置，不管你需要的是三个还是三百个。只要大小在程序运行时才能知道，比如一个文件有多少行、用户会输入多少条记录，这种写法就行不通了。动态内存解决了这个问题：在需要的时候申请需要的字节数，用完后再还回去。

相关的工具都在 <stdlib.h> 中：

#include <stdlib.h>

为什么需要堆

C 语言给程序提供了两块主要的内存区域。局部变量位于自动存储区（栈）：它们的大小由编译器决定，所在函数一返回就会消失。动态分配的内存位于堆：大小由你在运行时决定，这块内存会一直有效，直到你显式释放它。

第二个特性才是使用 malloc 的真正原因。函数可以分配一块内存，返回指针，而这块内存在调用者那里依然有效，局部数组永远做不到这一点。两块区域的详细对比见栈与堆。

malloc：申请字节

malloc 接收一个字节数，返回一个 void *，指向这么多字节的未初始化内存；如果请求失败，就返回 NULL。

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

int main(void) {
    int n = 5;

    int *scores = malloc(n * sizeof *scores);
    if (scores == NULL) {
        fprintf(stderr, "out of memory\n");
        return 1;
    }

    for (int i = 0; i < n; i++) {
        scores[i] = (i + 1) * 10;
    }

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

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

这段短小的程序里有四个要点，它们就是全部的规矩：

1. 大小表达式是 n * sizeof *scores。 把它读作“n 个 scores 所指向的东西”。
2. 在任何使用之前，先检查结果是否为 NULL。
3. 这块内存的用法和数组完全一样：scores[i] 之所以可行，是因为下标运算本质上就是指针运算。
4. 只释放一次，然后把指针设为 NULL。

注意这里没有对返回值做强制类型转换。在 C 语言中，void * 会自动转换为任何对象指针类型，写成 (int *)malloc(...) 只会增加干扰，还会掩盖遗漏 <stdlib.h> 头文件的问题。（C++ 要求这个转换，C 不需要。）

sizeof 惯用写法

为什么用 sizeof *scores 而不是 sizeof(int)？因为它永远不会过时。

int  *a = malloc(n * sizeof *a);     /* n ints, whatever int is here */
long *b = malloc(n * sizeof *b);     /* same line shape, right size */

/* the fragile form */
long *c = malloc(n * sizeof(int));   /* compiles, allocates too little */

最后一行是一个真实存在的 bug，而且没有任何编译器会警告：c 是 long *，分配的大小却是按 int 计算的，后半部分的每次写入都会越界。用 sizeof *c，大小就会自动跟随声明。

sizeof *p 并不会解引用 p：sizeof 在编译时只根据类型求值，所以即使 p 未初始化或为 NULL 也是安全的。

未初始化的内存

malloc 不会清空它给你的内存。这些字节里保存的是之前留下的任意内容。

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

int main(void) {
    int *p = malloc(4 * sizeof *p);
    if (p == NULL) {
        return 1;
    }

    /* reading before writing is undefined behavior - so write first */
    for (int i = 0; i < 4; i++) {
        p[i] = 0;
    }

    printf("%d %d %d %d\n", p[0], p[1], p[2], p[3]);

    free(p);
    return 0;
}

如果你希望内存自动清零，calloc 可以一步完成，参见 calloc 和 realloc。

free：归还内存

free(p) 把这块内存还给分配器。三条规则：

• 传入 malloc 返回的原始指针，而不是移动过的指针。free(p + 1) 是未定义行为。
• 每块内存只释放一次。释放两次就是重复释放（double free），会破坏分配器自己的记录。
• 释放之后，指针就失效了。继续使用它就是释放后使用（use-after-free）。

int *p = malloc(sizeof *p);
free(p);
*p = 5;        /* use-after-free - undefined behavior */
free(p);       /* double free - undefined behavior */

这两行都不一定会立即崩溃，这正是它们危险的地方：程序可能运行好几分钟，然后在毫不相关的地方出错。最省事的防御办法是把指针清空：

free(p);
p = NULL;

C 标准明确规定 free(NULL) 什么也不做，所以之后再调用一次 free(p) 也无害，而 *p 会在真正出错的位置立即崩溃，而不是悄悄破坏数据。

一个完整的动态数组

这就是真实分配的样子：在运行时读取数量，按它确定内存大小，使用，然后释放。

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

int main(void) {
    int n = 8;   /* imagine this came from input or a file */

    double *values = malloc((size_t)n * sizeof *values);
    if (values == NULL) {
        fprintf(stderr, "allocation of %d doubles failed\n", n);
        return 1;
    }

    for (int i = 0; i < n; i++) {
        values[i] = 1.0 / (i + 1);
    }

    double sum = 0.0;
    for (int i = 0; i < n; i++) {
        sum += values[i];
    }

    printf("sum of 1/1 .. 1/%d = %f\n", n, sum);
    printf("block holds %zu bytes\n", (size_t)n * sizeof *values);

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

当大小变大时，把数量转换为 size_t 就很重要了：如果 n 是普通的 int，n * sizeof *values 可能在乘积传给 malloc 之前就溢出，得到一块比预期小得多的内存。用 size_t 做乘法可以避免这个问题。

在函数内部分配

正是堆的生命周期规则让下面的写法合法，同时也让返回局部数组变得非法：

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

/* caller owns the returned block and must free it */
char *duplicate(const char *text) {
    size_t len = strlen(text);
    char *copy = malloc(len + 1);
    if (copy == NULL) {
        return NULL;
    }
    memcpy(copy, text, len + 1);
    return copy;
}

int main(void) {
    char *greeting = duplicate("hello, heap");
    if (greeting == NULL) {
        fprintf(stderr, "out of memory\n");
        return 1;
    }

    greeting[0] = 'H';
    printf("%s\n", greeting);

    free(greeting);
    return 0;
}

len + 1 为空终止符留出了位置，这和 字符串 中各处的大小规则相同。再注意函数上方的注释：当一个函数返回已分配的内存时，由谁来释放它是函数约定的一部分。把这一点写下来不是走形式，它是防止内存泄漏的唯一保障。

堆上的结构体

同样的惯用写法适用于任何类型：

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

struct Point {
    double x;
    double y;
};

int main(void) {
    struct Point *p = malloc(sizeof *p);
    if (p == NULL) {
        return 1;
    }

    p->x = 3.0;
    p->y = 4.0;
    printf("(%.1f, %.1f)\n", p->x, p->y);

    /* an array of them */
    int n = 3;
    struct Point *path = malloc((size_t)n * sizeof *path);
    if (path == NULL) {
        free(p);
        return 1;
    }

    for (int i = 0; i < n; i++) {
        path[i].x = i;
        path[i].y = i * i;
    }
    printf("last point: (%.1f, %.1f)\n", path[n - 1].x, path[n - 1].y);

    free(path);
    free(p);
    return 0;
}

注意第二个失败分支在返回之前释放了 p。一旦函数持有不止一块已分配的内存，每条错误路径都必须释放已经申请到的那些，这是内存泄漏中描述的泄漏最常见的来源。

检查清单

• 第一次使用之前，始终检查 malloc 是否返回 NULL。
• 用 n * sizeof *p 计算大小，并以 size_t 做乘法。
• 在 C 语言中不要对返回值做强制类型转换。
• malloc 分配的内存未初始化；先写再读。
• 用原始指针只释放一次，然后把它设为 NULL。
• 分配之后的每条错误路径，都必须释放已经持有的内存。