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 字节。调整有两种结局:原块后面正好有足够空闲空间,就在原地扩,原数据不动;后面被别的块占住,就在堆上另找一块足够大的,把原数据复制过去,再释放旧块,返回新地址。

课件写的是 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 成功后的旧指针视为已失效;继续用它访问是未定义行为。这和“地址看起来一样”是两回事。
六类错误,还有一类更难查的
课件列了六类。把它们按后果排一下,能看出哪些当场炸、哪些拖到线上。
- 解引用
NULL。int *p = malloc(INT_MAX / 4); *p = 20;这块请求可能失败,p可能是NULL,写进去立刻访问冲突。正确做法是先判NULL再用。 - 越界。
malloc(10 * sizeof(int))之后循环写p[0]到p[10],多写的那一个落在分配器自己的管理数据或下一个块上,可能现在不崩,等free时才崩。 free非动态内存。int a = 10; free(&a);传进去的是栈地址,分配器按堆块的布局去解析它,结果未定义。free块中间地址。p++之后free(p),p已经不是块首,分配器找不到这块的头部。- 重复释放。同一块
free两次,第二次读到的是已经回收的管理数据。第一次之后写p = NULL能挡住这一种。 - 忘记释放。函数里
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。 - 代码段:函数体的机器指令和只读常量,通常只读。

课件正文只写了四块,配图里还有两块:最上面的内核空间(用户代码不能读写),以及栈和堆之间的内存映射段。后者放文件映射、动态库和匿名映射;glibc 里较大的 malloc 请求会走 mmap,释放时直接还给系统,不回到堆的空闲链表。少了这一段,就解释不了“为什么大块内存释放后进程占用会降,小块不降”。
还有一句“堆的分配方式类似于链表”描述的是分配器的空闲链表,不是操作系统给堆内存的方式。
判断一段动态内存代码对不对,先看三件事:这块地址从哪里来、现在有几个指针指着它、最后一次使用它时它还在不在。
还没有评论 — 第一条由你来留。