C语言动态内存管理深度分析

作者：袖梨 2026-06-14

在C语言编程中，栈上开辟的int 、char、定长度数组，空间大小固定、无法灵活调整。但实际开发中，很多场景需要程序运行时才确定内存大小、动态扩容 / 缩容，这就必须掌握动态内存管理。

一、为什么需要动态分配内存？

int vsl = 20;       在栈空间上开辟4字节
char arr[10] = {0}; 在栈空间上开辟10字节

我们之前所学的变量创建是在栈区上，根据类型字节的大小分配空间，但是这样的开辟空间方式有两个特点：

空间大小固定：
编译时就确定
，运行中无法修改。
数组长度不可变：声明时必须指定长度，一旦定义无法扩容 / 缩容。

而实际需求往往是动态的：比如用户输入数据量不确定、列表需要随时增减元素。C 语言引入

堆区

动态内存分配

，由程序员手动申请、释放，完美解决上述问题，灵活可控！

二、核心动态开辟函数

1.malloc：申请指定大小的连续内存

函数原型
void* malloc(size_t size);

头文件：
#include<stdlib.h>
功能：向堆区申请size字节的连续可用内存，返回起始地址。
参数：size为申请的字节数。
返回值：成功返回
void*
类型的起始地址（需强制类型转换）；失败返回
NULL
（内存不足时），必须判空。
注意：申请的内存
未初始化
，是随机值。

2.free：释放动态申请的内存

函数原型
void free(void* ptr);

头文件：
#include<stdlib.h>
功能：
释放
ptr指向的
堆区动态内存
。
参数：ptr为动态内存起始地址。
注意：如果参数ptr指向的空间
不是动态开辟
的，那么
free函数的行为是未定义的
；如果参数ptr
是NULL指针
，则函数什么事都不做。

3.calloc：申请并初始化内存

函数原型
void* calloc(size_t num,size_t size);

功能：申请num个、每个size字节的连续内存，
自动初始化为 0
。
与malloc的区别：calloc会初始化内存为0，malloc是随机值。
返回值：同malloc，成功返回地址，失败返回NULL。

4.realloc：动态调整内存大小

realloc函数的出现让动态内存管理更加灵活。
有时候我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的使用内存，我们⼀定会对内存的大小做灵活的调整。那realloc
函数就可以做到对动态开辟内存大小的调整。

函数原型
void* realloc(void* ptr,size_t size);

功能：调整ptr 指向的动态内存大小为size字节，
保留原数据
。
参数：
ptr为原内存地址
，NULL时等价于malloc；
size为调整后的新字节数
。
返回值：成功返回新地址（
可能与原地址不同
）；失败返回NULL，原内存不变，不释放。
扩容两种情况：
1. 原内存后有足够空间：
  直接追加
  ，
  返回原地址
  ；
2. 原内存后无空间：开辟新空间→拷贝原数据→释放旧空间→
  返回新地址
  。

三、动态内存常见的6大错误

1.对NULL指针解引用

malloc、realloc、calloc函数返回值可能为NULL，直接解引用会崩溃。

2.对动态开辟空间的越界访问

申请10个int，访问第11个int，越界访问。

3.对非动态开辟内存使用free释放

free(栈区变量)，行为未定义。

4.使用free释放一块动态开辟内存的一部分

指针偏移后free，行为未定义。

5.对同一块动态内存多次释放

同一块内存被多次释放后，程序崩溃。

6.动态开辟内存未释放（内存泄漏）

动态内存忘记释放，程序运行占用内存不释放。

四、动态内存经典笔试题分析

1.传值调用，内存泄漏

结果：程序崩溃，内存泄漏。
原因：GetMemory 是值传递，p 是 str 的临时拷贝，修改 p 不影响原 str，str 仍为 NULL，解引用崩溃；malloc 的内存无法释放，泄漏。

改进方法1：使用二级指针作为参数。

改进方法2：函数返回指针。

2.返回栈区地址，野指针

结果：打印随机值，野指针。
原因：p 是栈区局部数组，函数返回后栈帧销毁，p 的地址失效，str 指向野指针。

改进方法1：使用静态区内存

3.传址调用，内存泄漏

结果：正常打印 hello，内存泄漏，程序崩溃。
原因：二级指针传递，GetMemory 修改 str 本身，指向堆区内存，合法可用；malloc 的内存无法释放，泄漏。

4.free后野指针

结果：程序崩溃或打印随机值。
原因：free 后 str 未置空，仍指向已释放的内存（野指针），非法访问。

五、柔性数组：结构体的动态数组

1.柔性数组的定义

C99 规定：

结构体

最后一个成员可以是

未知大小的数组

，称为柔性数组

// 写法1：常用
struct S 
{
    int n;
    int arr[];柔性数组成员
};
// 写法2：部分编译器支持
struct S 
{
    int n;
    int arr[0];
};

2.柔性数组的特点

结构体中至少有一个其他成员（不能只有柔性数组）。
sizeof(结构体)
不包含柔性数组的内存。
必须用malloc一次性分配结构体 + 柔性数组的内存。

struct S
{
    int n;
    char c;
    int arr[];
};
int main()
{
    printf("%zun",sizeof(struct S)); 8
    return 0;
}

3.柔性数组 vs 指针成员

struct S
{
    int n;
    int arr[];柔性数组成员
};
int main()
{
    struct S* p=(Struct S*)malloc(sizeof(struct S)+10*sizeof(int));
    1.一次malloc，同时包含结构体n+arr数组空间
    if(p==NULL)
    { 
        perror("malloc");//给出错误信息
        rerturn 1;
    }
    p->n=100;
    for(int i=0;i<10;i++)
    {
        ps->arr[i]=i+1;
    }
    free(p);//一次释放空间
    p=NULL;
    return 0;
}

struct S
{
    int n;
    int* arr; 指针变量
};
int main()
{
    struct S* p=(struct S*)malloc(sizeof(struct S));
    1.只开辟了int n + int* arr的大小，此时arr是野指针，没有指向任何可用数组空间
    if(p==NULL)
    {
        perror("malloc");
        return 1;
    }
    p->n=100;
    int* ptr=(int*)malloc(10*sizeof(int));
    2.单独创建arr指向的数组空间
    p->arr=ptr;
    for(int i=0;i<10;i++)
    {
        ps->arr[i]=i+1;
    }
    free(p->arr); 3.第一次释放数组数据空间
    free(p);      4.第二次释放结构体空间
    p=NULL;
    return 0;
}