动态内存管理（malloc，calloc，realloc，free）+经典笔试题

动态内存管理

一. malloc 和 free
- 1. malloc
- 2. free
二. calloc
三. realloc
四.动态内存的错误
- 1.对NULL指针的解引用操作
- 2.对动态开辟空间的越界访问
- 3.对非动态开辟内存使用free释放
- 4.使用free释放一块动态开辟内存的一部分
- 5.对同一块动态内存多次释放
- 6.动态开辟内存忘记释放（内存泄漏）
五.动态内存经典笔试题分析

前言：

当我们要开辟一块连续的内存空间时，我们第一时间想到的可能是数组。但是一但开辟了数组，数组的大小就确定了，无法调整数组的大小。
有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。
于是动态内存开辟函数（malloc，calloc，realloc，free）应运而生，下文带您一一了解其中的奥秘。

一. malloc 和 free

1. malloc

void* malloc(size_t size);

解释：在堆区中开辟一块大小为 size 个字节的空间，返回指向这块空间的起始地址（泛型指针void*）。

因为这块空间存放的数据类型不知（由程序员自己确定），所以用泛型指针接收该地址，在使用的时候记得养成一个好习惯：强制类型转换为自己需要的数据类型。

如果开辟成功，则返回一个指向开辟好空间的指针。
如果开辟失败，则返回一个 NULL 指针，因此malloc的返回值一定要做检查。
返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候程序员自己来决定。
如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。

2. free

void free(void* ptr);

解释：free是用来对动态内存的释放和回收的。free 对指针 ptr 指向的内容释放掉，但是指针仍然指向这块空间，若后面不再使用，及时将 ptr 置为 NULL，否则产生野指针。

如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
如果参数 ptr 是NULL指针，则函数什么事都不做。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main()
{
	//在堆区申请10个整形空间
	int* p=(int*)malloc(10*sizeof(int));
	if (p == NULL)
	{
		//开辟空间失败
		perror("malloc");//打印错误信息
		//printf("%s\n", strerror(errno));//也是打印错误信息
		return 1;
	}
	//使用这块空间
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;
	}
	//打印这块空间
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	//释放这块空间
	free(p);//将这块空间还给了操作系统，我们已经没有权限再使用这块空间了
	        //但是p仍然指向那块空间

	p = NULL;//若不将p置为NULL，那么p就是野指针
	return 0;
}

在这里插入图片描述

总结：

动态内存开辟的函数头文件都是 stdlib.h。
如果不释放的话，程序结束的时候也会被操作系统自动释放。
但是为了防止内存泄漏，将其置为NULL。这是一个好习惯。

二. calloc

void* calloc(size_t num, size_t size);

解释：在堆区中开辟一块大小为 num * size 个字节的空间，返回指向这块空间的起始地址，其中 num 为数据的个数，size 为单个数据的字节数，同时把申请的空间的每个字节初始化为全为0。


#include<stdio.h>
#include<stdlib.h>
int main()
{
	//在堆区申请10个整形空间
	int* p = (int*)calloc(10, sizeof(int));
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	//使用空间
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	//释放
	free(p);
	p = NULL;
	return 0;
}

在这里插入图片描述

三. realloc

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

解释：调整动态内存开辟的空间，ptr 是那块空间的起始地址，size 是调整后的那块空间的字节的个数，返回指向这块空间的起始地址。

#include<stdio.h>
#include<stdlib.h>
int main()
{
	//在堆区申请10个整形空间
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//调整空间——变成20个整形空间
	int* ptr = (int*)realloc(p, 20 * sizeof(int));//注意：要用新的指针来接收
	if (ptr != NULL)
	{
		p = ptr;
	}
	else
	{
		//开辟失败
		return 1;
	}
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		*(p + i) = i + 1;
	}
	for (i = 0; i < 20; i++)
	{
		printf("%d ", *(p + i));
	}
	//释放
	free(p);
	p = NULL;
	return 0;
}

在这里插入图片描述

注意：也许有些人有疑问为什么要用新的指针接收返回的地址，直接用原来的指针接收不行吗？答案是不行的，在realloc调整动态内存开辟的空间有3中情况，代码如下：

int main()
{
	int* p = (int*)malloc(10);
	//...
	if (p != NULL)
	{
		int* ptr = (int*)realloc(p, 20);
		//...
	}
	return 0;
}

情况1：

开辟的空间后面有足够且连续的空间，只需返回空间的起始地址即可。

情况2：

如果后续的空间不够，realloc 函数直接在堆区找一块新的满足大小的空间，将旧的地址，拷贝到新的地址。
自动释放旧的地址指向的空间，不需要手动 free，返回新的空间的起始地址。

在这里插入图片描述

情况3：

堆区已经没有满足情况的连续空间了，返回NULL。

realloc函数也能开辟空间，代码如下：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)realloc(NULL, 10 * sizeof(int));//等价于malloc(40)
	if (p == NULL)
	{
		//...
	}
	return 0;
}

四.动态内存的错误

1.对NULL指针的解引用操作

如果将一个空指针（NULL）进行解引用操作，程序会遇到未定义行为，会导致程序崩溃。这是因为空指针并不指向任何有效的内存地址，尝试解引用它会导致访问非法内存，从而导致程序崩溃。
因此，在解引用指针之前，应该始终先检查指针是否为空。

错误代码如下：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(10 * sizeof(int));//可能会开辟失败导致，p等于NULL
	//if (p == NULL)
	//{
	//	  perror("malloc");
	//	  return 1;
	//}
	
	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;//如果p等于NULL，对其进行解引用操作，程序会崩溃
	}

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

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

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 40; i++)//越界访问，程序崩溃
	{
		*(p + i) = i + 1;
	}

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

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

#include<stdio.h>
int main()
{
	int a = 10;
	int* p = &a;
	//...

	free(p);//程序崩溃
	p = NULL;
	return 0;
}

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

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*p = i;
		p++;//修改了指针p
	}

	free(p);//free释放一块动态开辟内存的一部分，程序崩溃
	p = NULL;
	return 0;
}

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

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用
	free(p);//p为野指针

	//...
	free(p);//对同一块动态内存多次释放，程序崩溃
	p = NULL;
	return 0;
}

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

内存泄漏：在程序执行过程中，动态分配的内存空间在程序不再需要时没有被正确释放的情况。这会导致程序在运行过程中持续耗费内存空间而不释放，最终可能导致系统性能下降，甚至导致程序崩溃。

#include<stdio.h>
#include<stdlib.h>
void test()
{
	int flag = 1;
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
		return;
	//使用
	if (flag)
		return;//未释放，函数提前结束，就找不到那块空间，导致内存泄漏
		
	free(p);
	p = NULL;
}
int main()
{
	test();
	//......
	//只有程序结束了，空间才被释放
	return 0;
}