int arr[10] 占多少字节,编译时就定下来了;块内的 int arr[n] 这种变长数组(variable-length array,VLA)把大小推迟到运行期,但 C11 把它列为可选特性,MSVC 至今没有实现。需要在运行时决定申请多大,标准给的工具在 <stdlib.h> 里:malloc、calloc、realloc、free。

malloc 申请的是字节数,free 只认块首地址

void *malloc(size_t size);

size 是字节数,不是元素个数。malloc(10) 只给 10 个字节,存 int 连三个都放不下。参数类型 size_t 是无符号整数类型,sizeof 的结果也是 size_t,所以 malloc(n * sizeof *p) 是最不容易出错的写法。

返回值是 void *:成功时指向一块连续、按 max_align_t 对齐的内存;失败时返回 NULL。C 允许 void * 隐式转换成任何对象指针类型,C 里不必写 (int *)malloc(n * sizeof *p) 这样的强制转换。强制转换本身不改变结果,但会掩盖“忘了包含 <stdlib.h>”这类问题——老编译器在没见过声明时按返回 int 处理,指针被截断,运行时才出问题。

申请到的内存没有初始化。里面可能是全零,那是操作系统刚映射的页;也可能是上一次释放留下的数据。读到什么取决于分配器的历史,不能假设是新块就干净。

size 为 0 时,标准的规定是实现定义(implementation-defined):要么返回空指针,要么返回一个不能解引用、但可以传给 free 的唯一指针。课件写成“标准是未定义的”,这两类行为在标准里的分量不同——实现定义要求实现文档写清楚选哪种,未定义则什么都可以发生。

#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
    int n = 0;
    if (scanf("%d", &n) != 1 || n <= 0)
        return 1;
 
    int *p = malloc((size_t)n * sizeof *p);
    if (p == NULL)
        return 1;
 
    for (int i = 0; i < n; i++)
        p[i] = i;
 
    free(p);
    p = NULL;
    return 0;
}

free 的原型是 void free(void *ptr);,它接受的地址只有两种:malloc/calloc/realloc 返回的块首地址,或者 NULL。传 NULL 时它什么也不做,这是标准保证的;传栈上变量的地址、传块中间某个元素的地址、对同一块释放两次,都是未定义行为。

free(p); p = NULL; 课件在这里问“是否有必要”。有必要,但理由不是 free 需要:free 对 NULL 本来就是空操作。置空是为了让这个变量再也指不到已经归还的块,避免后面误读(use-after-free)和误释放(double free)。它只能管住这一个变量;同一个块如果还有别的指针指着,那些指针照样悬空。

calloc 多做一步清零,realloc 可能搬家

void *calloc(size_t num, size_t size);

申请 num 个、每个 size 字节,并把整块内存的每个字节置 0。参数写法让“几个元素、每个多大”直接写进调用点;malloc(10 * sizeof(int)) 与 calloc(10, sizeof(int)) 字节数相同,后者多一次清零。对内容要求全零时,calloc 比 malloc 加 memset 更直接。

num * size 的乘积可能溢出 size_t,回绕之后得到的是一个小数;实现若不检查,就可能分配出远小于预期的块。glibc 会检查并返回 NULL,标准没有强制每个实现都这么做;传入外部数据时,在调用前先做一次除法判断更稳。

#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
    int *p = calloc(10, sizeof *p);
    if (p == NULL)
        return 1;
 
    for (int i = 0; i < 10; i++)
        printf("%d ", p[i]);      /* 0 0 0 0 0 0 0 0 0 0 */
 
    free(p);
    p = NULL;
    return 0;
}

realloc 的原型是 void *realloc(void *ptr, size_t size);,把 ptr 指向的块调整到 size 字节。调整有两种结局:原块后面正好有足够空闲空间,就在原地扩,原数据不动;后面被别的块占住,就在堆上另找一块足够大的,把原数据复制过去,再释放旧块,返回新地址。

上图是情况 1:ptr 后面那段标着“尚未分配”的空间够用,原地扩到 40 字节;下图是情况 2:紧挨着的红色区域已被占用,只能另找一块,数据要搬过去,ptr 收到的是新地址

课件写的是 realloc“还会将原来内存中的数据移动到新的空间”,这只描述了第二种结局。原地扩容时数据一个字节都不用动,地址也不变。

失败时返回 NULL,原块不会被释放,ptr 仍然有效——这条是 realloc 最容易出事的地方。直接写 ptr = realloc(ptr, 1000);,失败后 ptr 变成 NULL,旧块的地址丢了,那块内存再也 free 不掉。

#include <stdlib.h>
 
int main(void)
{
    int *p = malloc(25 * sizeof *p);
    if (p == NULL)
        return 1;
 
    for (int i = 0; i < 25; i++)
        p[i] = i;
 
    int *tmp = realloc(p, 100 * sizeof *p);
    if (tmp == NULL)
    {
        free(p);
        return 1;
    }
    p = tmp;
 
    free(p);
    return 0;
}

成功后旧指针立即失效,哪怕这次是原地扩容、地址没变。C 标准把 realloc 成功后的旧指针视为已失效;继续用它访问是未定义行为。这和“地址看起来一样”是两回事。

六类错误,还有一类更难查的

课件列了六类。把它们按后果排一下,能看出哪些当场炸、哪些拖到线上。

  1. 解引用 NULL。int *p = malloc(INT_MAX / 4); *p = 20; 这块请求可能失败,p 可能是 NULL,写进去立刻访问冲突。正确做法是先判 NULL 再用。
  2. 越界。malloc(10 * sizeof(int)) 之后循环写 p[0] 到 p[10],多写的那一个落在分配器自己的管理数据或下一个块上,可能现在不崩,等 free 时才崩。
  3. free 非动态内存。int a = 10; free(&a); 传进去的是栈地址,分配器按堆块的布局去解析它,结果未定义。
  4. free 块中间地址。p++ 之后 free(p),p 已经不是块首,分配器找不到这块的头部。
  5. 重复释放。同一块 free 两次,第二次读到的是已经回收的管理数据。第一次之后写 p = NULL 能挡住这一种。
  6. 忘记释放。函数里 malloc 完直接返回,指针随栈帧消失,堆上的块还在。程序一直跑就一直涨,这就是内存泄漏。
#include <stdlib.h>
 
void bad(void)
{
    int a = 10;
    free(&a);              /* 栈地址,不是堆块 */
 
    int *p = malloc(10 * sizeof *p);
    p++;                   /* 不再是块首 */
    free(p);
 
    int *q = malloc(10 * sizeof *q);
    free(q);
    free(q);               /* 同一块释放两次 */
}

课件没单列、但比前面几类更难查的是释放后继续用:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main(void)
{
    char *s = malloc(16);
    if (s == NULL)
        return 1;
 
    strcpy(s, "hello");
    free(s);
    printf("%s\n", s);
    return 0;
}

这段可能打印 hello、可能打印乱码、可能直接崩,三种都“符合标准”。free 之后置 NULL 只能防住通过 s 再访问;如果别处还存着同一地址,那块内存已经交回分配器,随时可能被下一次 malloc 拿走。

四道题都在问同一件事:实参能不能被改

四道笔试题表面上在考 malloc,实际都在考 C 的传参规则:函数拿到的是实参的拷贝,想让函数改外面的指针,必须把那个指针的地址传进去。

第一题:

void GetMemory(char *p)
{
    p = (char *)malloc(100);
}
 
void Test(void)
{
    char *str = NULL;
    GetMemory(str);
    strcpy(str, "hello world");
    printf(str);
}

p 是 str 的拷贝。malloc 的返回值写进了 p,函数返回时 p 随栈帧消失,str 仍然是 NULL。strcpy 往 NULL 写,访问冲突;即便不崩,那 100 字节也没有任何变量记着,已经泄漏。printf(str) 还把数据当格式串用,字符串里出现 %n 就能改写内存,正确写法是 printf("%s", str)。

第二题:

char *GetMemory(void)
{
    char p[] = "hello world";
    return p;
}

p 是函数栈帧里的局部数组,函数一返回,这块栈就作废。返回的地址指向一块随时会被下一次函数调用覆盖的内存。Debug 构建里常常“看起来能跑”,因为那块栈还没被复用;换个优化级别或中间插一次 printf,输出就变了。

第三题:

void GetMemory(char **p, int num)
{
    *p = (char *)malloc(num);
}
 
void Test(void)
{
    char *str = NULL;
    GetMemory(&str, 100);
    strcpy(str, "hello");
    printf(str);
}

传进去的是 &str,类型 char **,函数通过 *p 写回 str,这次 str 真的拿到了地址。代码仍然有没收尾的地方:malloc 的返回值没判 NULL,函数结束也没 free(str),printf(str) 同样该改成 printf("%s", str)。

第四题:

void Test(void)
{
    char *str = (char *)malloc(100);
    strcpy(str, "hello");
    free(str);
    if (str != NULL)
    {
        strcpy(str, "world");
        printf(str);
    }
}

free(str) 之后 str 还是原来的值,if 永远为真,strcpy 往已归还的块里写。这个 str != NULL 判断没有意义;真正要做的是在 free 之后立刻 str = NULL,或者把后面这段逻辑删掉。

柔性数组:结构体和它的尾巴只分配一次

结构体的最后一个成员可以写成不完整数组类型:

struct packet
{
    int len;
    char data[];
};

这是 C99 引入的柔性数组成员(flexible array member)。data 不占 sizeof 的空间,sizeof(struct packet) 在 int 为 4 字节的实现上是 4;它的空间要跟结构体一起在 malloc 里申请。

课件先写 int a[0],再说“有些编译器报错就改成 int a[]”,顺序反了。char data[] 是标准写法;char data[0] 是 GCC 的零长数组扩展,开 -pedantic 会告警。新代码写标准那种。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
struct packet
{
    int len;
    char data[];
};
 
int main(void)
{
    struct packet *pkt = malloc(sizeof *pkt + 100);
    if (pkt == NULL)
        return 1;
 
    pkt->len = 100;
    strcpy(pkt->data, "hello");
    printf("%d %s\n", pkt->len, pkt->data);
 
    free(pkt);
    pkt = NULL;
    return 0;
}

对比“结构体里放一个 int *p_a,再单独 malloc 一块”的写法,柔性数组省的不只是分配次数。整个结构体和尾部空间是一块连续内存,调用方拿到的指针只 free 一次就够了;指针版本的成员要单独释放,用户不知道这件事,就会漏掉这次释放。课件那个对比示例里,for (i = 0; i < 100; i++) 的 i 没有声明,照抄编译不过,补一行 int i = 0; 才对。

连续内存对访问速度有帮助,也能少一些分配器碎片;省下的寻址成本有限,真正值钱的是释放责任只有一次。

栈、堆、静态区、代码段,还有图上那两块

课件正文列了四块:

  • 栈区:函数调用时局部变量、参数、返回地址在这里;函数返回自动回收;由处理器指令直接调整栈指针,快,但容量有限。
  • 堆区:malloc 家族的地盘;由程序员申请和释放;程序退出时操作系统会回收整个进程的堆,运行期间的泄漏不会自己消失;分配器内部用空闲链表管理。
  • 数据段(静态区):全局变量和 static 变量;程序开始到结束一直在;已初始化的通常在 .data,未初始化或初始化为 0 的通常在 .bss。
  • 代码段:函数体的机器指令和只读常量,通常只读。

左边是变量声明,右边是地址空间:全局和 static 变量箭头指向数据段,局部变量指向栈,malloc/calloc/realloc 指向堆,字符串字面量指向只读的代码段;右侧还画出了内核空间和内存映射段

课件正文只写了四块,配图里还有两块:最上面的内核空间(用户代码不能读写),以及栈和堆之间的内存映射段。后者放文件映射、动态库和匿名映射;glibc 里较大的 malloc 请求会走 mmap,释放时直接还给系统,不回到堆的空闲链表。少了这一段,就解释不了“为什么大块内存释放后进程占用会降,小块不降”。

还有一句“堆的分配方式类似于链表”描述的是分配器的空闲链表,不是操作系统给堆内存的方式。

判断一段动态内存代码对不对,先看三件事:这块地址从哪里来、现在有几个指针指着它、最后一次使用它时它还在不在。