从malloc到free：动态内存管理全解析

1.为什么要有动态内存管理

我们已经掌握的内存开辟方法有：

int main()
{
	int val = 20;//在栈空间上开辟四个字节
	char arr[20] = { 0 };//在栈空间上开辟10个字节的连续空间
	return 0;
}

上述开辟的内存空间有两个特点：

1.空间开辟的时候大小已经固定

2.数组在声明的时候，必须指定数组的长度，数组空间一旦确定了大小就不能调整

但是对于所需内存空间的需求，不仅仅是上述的情况，有时候我们需要的空间大小在程序运行时才能知道，那数组就不能满足我们的需求了。

C语言由此引入了动态内存开辟，让程序员可以自己申请和释放空间。

2.malloc和free

C语言提供了一个动态内存开辟的函数malloc，函数原型如下：

void* malloc(size_t size);

这个函数向内存申请⼀块连续可⽤的空间，并返回指向这块空间的指针。

• 如果开辟成功，则返回⼀个指向开辟好空间的指针。

• 如果开辟失败，则返回⼀个 NULL 指针，因此malloc的返回值⼀定要做检查。

• 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使⽤的时候使⽤者自己来决定。

• 如果参数 size 为0，malloc的⾏为是标准是未定义的，取决于编译器。

malloc详细解析网页

C语言还提供了一个函数free，专门用来做动态内存的释放和回收的，函数原型如下：

void* free(void* ptr);

free函数⽤来释放动态开辟的内存。

• 如果参数 ptr 指向的空间不是动态开辟的，那free函数的⾏为是未定义的。

• 如果参数 ptr 是NULL指针，则函数什么事都不做。

malloc和free都声明在 stdlib.h 头⽂件中。

free详细解析网页

学完了两个函数，我们来举一个例子帮助大家理解：

int main()
{
	int* pz = (int*)malloc(10 * sizeof(int));//注意，malloc自己返回的指针类型是void*的，所以需要强制转换为int*类型
	if (pz == NULL)//如果创建失败，返回的将是空指针
	{
		perror("malloc");//打印错误，为什么创建失败
		return 1;//结束程序
	}
	for (int i = 0; i < 10; i++)
	{
		*(pz + i) = i + 1;
	}
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", *(pz + i));
	}
	free(pz);//动态内存使用完我们应该主动进行回收
	pz = NULL;//回收之后，内存空间将会释放，但是pz指针仍然会指向那个地址，我们需要将他置为空指针
	return 0;
}

观察结果，我们可以发现利用malloc创建的堆空间实现了与数组创建的栈空间一样的效果，它们都是一块连续的空间。上述是创建成功的示例，我们再来看一个失败的案例：

3.calloc和realloc

C语言还提供了一个函数叫calloc，他也是用来实现动态内存分配的，函数原型如下：

void* calloc(size_t num, size_t size);

• 函数的功能是为 num 个⼤⼩为 size 的元素开辟⼀块空间，并且把空间的每个字节初始化为0。

• 与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为0

calloc详细解析网页

看代码：

int main()
{
	int* pz = (int*)calloc(10, sizeof(int));
	if (pz == NULL)
	{
		perror("calloc");
		return 1;
	}
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", *(pz + i));
	}
	free(pz);
	pz = NULL;
	return 0;
}

近乎一样的代码，打印的结果完全不同，这就是malloc和calloc的区别。

接下来我们要学的最后一个函数是realloc,realloc函数的出现让动态内存管理更加灵活。有时会我们发现过去申请的空间太⼩了，有时候我们⼜会觉得申请的空间过⼤了，那为了合理的申请内存，我们⼀定会对内存的⼤⼩做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。他的函数原型如下：

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

• ptr 是要调整的内存地址

• size 调整之后新⼤⼩

• 返回值为调整之后的内存起始位置。

• 这个函数调整原内存空间⼤⼩的基础上，还会将原来内存中的数据移动到 新 的空间。

realloc详细解析网页

realloc在调整内存空间时存在两种情况：

◦ 情况1：原有空间之后有⾜够⼤的空间

◦ 情况2：原有空间之后没有⾜够⼤的空间

情况1

当是情况1 的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发⽣变化。

情况2

当是情况2 的时候，原有空间之后没有⾜够多的空间时，扩展的⽅法是：在堆空间上另找⼀个合适⼤⼩的连续空间来使⽤。这样函数返回的是⼀个新的内存地址。原有空间的数值会被存入新的空间内。

由于上述的两种情况，realloc函数的使⽤就要注意⼀些。

int main()
{
	int* pz1 = (int*)malloc(10 * sizeof(int));
	if (pz1 == NULL) 
	{
		perror("malloc");
		return 1;
	}

	//业务处理
	//发现内存不够，需要扩充

	//方法1
	//pz1 = (int*)realloc(pz1, 20 * sizeof(int));

	//方法2
	int* pz2 = NULL;
	pz2 = (int*)realloc(pz1, 20 * sizeof(int));
	if (pz2 == NULL)
	{
		perror("realloc");
		free(pz1);
		return 1;
	}
	pz1 = pz2;
	//业务处理
	free(pz1);
	pz1 = NULL;
	return 0;
}

方法一存在下面风险：

内存泄漏风险：

若 realloc 失败返回 NULL，原指针 pz1 会被直接覆盖为 NULL。

后果：原内存（10个int的空间）彻底丢失，无法再被释放，导致内存泄漏。

空指针操作风险： 未检查返回值直接使用 pz1，若 realloc失败，后续操作 pz1 的行为会引发未定义行为（如访问空指针导致程序崩溃）。

使用方法二可以很好的避免发生这些错误。

4.常见的动态内存错误

4.1对NULL指针的解引用操作

int main()
{
	int* p = (int*)malloc(INT_MAX);
	*p = 10;
	printf("%d\n", *p);
	free(p);
	p = NULL;
	return 0;
}

上述代码我们没有检查malloc函数创建失败返回空指针的可能，实际上改代码p返回的就是空指针，而我们对空指针进行解引用操作的行为时错误的，所以大家在利用malloc等函数申请内存时一定要检查是否成功申请，否则返回的可能是空指针。

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

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	for (int i = 0; i < 12; i++)
	{
		*(p + i) = i;//越界访问
	}
	free(p);
	p = NULL;
	return 0;
}

上述代码我们利用malloc函数像内存申请了40个字节的空间，但我们在for循环中却访问了48个字节的空间，在编译时程序肯定是会崩溃的，这属于越界访问。

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

int main()
{
	int a = 10;
	int* p = &a;
	free(p);
	p = NULL;
	return 0;
}

free函数只能释放动态开辟的内存，他不能释放栈空间的内存空间，上述代码也会报错。

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

int main()
{
	int* p = (int*)malloc(100);
	p++;
	free(p);
	p = NULL;
	return 0;
}

free函数不能这样释放内存，他的参数只能是开辟动态内存的起始地址，上述代码也会在编译时报错。

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

int main()
{
	int* p = (int*)malloc(100);
	free(p);
	free(p);
	return 0;
}

free函数是不能对一块动态内存进行重复释放，编译器会报错。

4.6动态开辟内存忘记释放（内存泄露）

void test()
{
	int* p = (int*)malloc(100);
	if (p != NULL)
	{
		*p = 20;
	}
}

int main()
{
	test();
	return 0;
}

上述代码在运行时编译器虽然不会直接报错，但他是极不安全的，存在内存泄漏问题。

切记：动态开辟的空间⼀定要释放，并且正确释放。

5.动态内存经典笔试题分析

5.1题目1：

void GetMemory(char* p)
{
	p = (char*)malloc(100);
}

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

上述代码运行Test函数会产生什么样的结果？

什么都不会打印。

看起来问题不大，其实错漏百出：

指针传递问题（最核心问题）： GetMemory函数接收的是char* p的副本（值传递）， 函数内修改的是副本指针，不影响外部的str 导致str在Test函数中始终为NULL ，参考传值调用

内存泄漏： malloc分配的内存没有被释放，而且由于指针问题，分配的内存甚至无法被访问

空指针解引用： strcpy试图向NULL指针写入数据，会导致程序崩溃

我们这里提供两种方法改进。

第一种，改用二级指针，类似传址调用。

第二种，函数返回指针。

exit(EXIT_FAILURE);包含在头文件#include<stdlib.h>

exit() 函数：立即终止程序，清理缓冲区并关闭所有打开的文件。

EXIT_FAILURE：标准宏（通常值为1），表示程序异常终止。

5.2题目2：

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

void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}

int main()
{
	Test();
	return 0;
}

打印结果：

这个代码犯了一个很严重的错误，p数组他是一个局部变量，他只能在GetMemory函数内使用，出了该函数它的内存空间就被释放掉了，该函数返回的也是悬空指针，建议使用动态分配堆内存代替数组。

> 记住，永远不要返回局部变量的地址

5.3题目3：

void GetMemory(char** p, int num)
{
	*p = (char*)malloc(num);
}

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

int main()
{
	Test();
	return 0;
}

上述代码是可以打印正常结果的，但是还是我们上面所说的一些常见的动态内存错误，没有检查malloc返回的是否为空指针，没有释放动态开辟的内存，大家不要认为自己不会犯这种错误，作者反复提醒，望注意。

5.4题目4：

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

int main()
{
	Test();
	return 0;
}

这个代码同样为检查malloc函数创建失败的可能，但这题还有更大的错误，str经free函数释放后，变成了一个悬空指针，对悬空指针进行再操作的行为是未定义的（可能导致崩溃和数据损坏），所以我们应该养成释放后即使置空指针的习惯。

6.柔性数组

6.1柔性数组的介绍

在C99中，结构体的最后一个元素允许是未知大小的数组，这就叫柔性数组成员，如下：

struct st_type
{
	int i;
	int arr[];
};

柔性数组的特点：

• 结构中的柔性数组成员前⾯必须⾄少存在⼀个其他成员。

• sizeof 返回的这种结构⼤⼩不包括柔性数组的内存。

• 包含柔性数组成员的结构⽤malloc ()函数进⾏内存的动态分配，并且分配的内存应该⼤于结构的⼤⼩，以适应柔性数组的预期⼤⼩。

看下面代码：

6.2柔性数组的使用

typedef struct st_type
{
	int i;
	int arr[];
}type_1;

int main()
{
	type_1* pz = (type_1*)malloc(sizeof(type_1) + 20 * sizeof(int));
	pz->i = 100;
	for (int i = 0; i < 20; i++)
	{
		pz->arr[i] = i;
	}
	free(pz);
	pz = NULL;
	return 0;
}

上述的代码也可以设计成下面的形式：

typedef struct st_type
{
	int i;
	int* ps;
}type_1;

int main()
{
	type_1* pz = (type_1*)malloc(sizeof(type_1));
	pz->i = 100;
	pz->ps = (int*)malloc(20 * sizeof(int));
	for (int i = 0; i < 20; i++)
	{
		pz->ps[i] = i;
	}
	free(pz->ps);
	pz->ps = NULL;
	free(pz);
	pz = NULL;
	return 0;
}

上述代码并没有检查malloc返回空指针的可能性，这是可以改进的一点。

除此以外，你认为代码一和代码二哪个更优秀呢？

代码一更优秀，理由有二：

第⼀个好处是：⽅便内存释放，如果我们的代码是在⼀个给别⼈⽤的函数中，你在⾥⾯做了⼆次内存分配，并把整个结构体返回给⽤⼾。⽤⼾调⽤free可以释放结构体，但是⽤⼾并不知道这个结构体内的成员也需要free，所以你不能指望⽤⼾来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存⼀次性分配好了，并返回给⽤⼾⼀个结构体指针，⽤⼾做⼀次free就可以把所有的内存也给释放掉。

第⼆个好处是：这样有利于访问速度，连续的内存有益于提⾼访问速度，也有益于减少内存碎⽚。

加深结构体中成员数组与指针理解阅读

7.总结C/C++语言程序内存区域划分

C/C++程序内存分配的⼏个区域：

1. 栈区（stack）：在执⾏函数时，函数内局部变量的存储单元都可以在栈上创建，函数执⾏结束时 这些存储单元⾃动被释放。栈内存分配运算内置于处理器的指令集中，效率很⾼，但是分配的内 存容量有限。栈区主要存放运⾏函数⽽分配的局部变量、函数参数、返回数据、返回地址等。
2. 堆区（heap）：⼀般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配⽅ 式类似于链表。
3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
4. 代码段：存放函数体（类成员函数和全局函数）的⼆进制代码。