推荐|动态内存管理

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


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

上述开辟空间的方式有两个特点：

1.空间开辟大小是固定的。

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

但是有时我们需要的空间大小在程序运行时才能知道，那数组编译时开辟的空间就无法满足了。因此C语言引入了动态内存开辟，让程序员自己可以申请和释放空间。

二、malloc和free

1.malloc

C语言提供了一个动态开辟的函数：

void* malloc (size_t size);

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

①malloc声明在stdlib.h头文件中。

②若开辟成功，则返回指向开辟好空间的指针。

③若开辟失败，则返回NULL指针，因此malloc的返回值一定要检查。

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

⑤若size为0，malloc的行为是标准未定义的，取决于编译器。

2.free

free是用来做动态内存的释放和回收的，函数原型：

void free (void* ptr);

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

①若参数ptr指向的空间不是动态开辟的，那free函数的行为是未定义的。

②若参数ptr是NULL指针，则函数什么事都不做。

③free声明在stdlib.h头文件中。


#include<stdio.h>
#include<stdlib.h>
int main()
{
	//20个字节 - 存放5个整数
	int* p = (int*)malloc(20);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用空间
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i + 1;
	}
	//释放内存
	free(p);//传递给free函数的是要释放的内存空间的起始地址
	p = NULL;
	return 0;
}

三、calloc和realloc

1.calloc

calloc函数也用来动态内存分配，函数原型：

void* calloc (size_t num, size_t size);

①函数的功能为num个大小为size的元素开辟一块空间，并且把空间的每个字节初始化为0。

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


#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)calloc(5, sizeof(int));
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", *(p + i));//初始化为全0
	}
	free(p);
	p = NULL;
	return 0;
}

2.realloc

realloc函数的出现让动态内存管理更加灵活，有时我们发现过去申请的空间太小了，有时又觉得申请的空间太大了，所以我们要根据实际情况对内存的大小进行灵活的调整。realloc函数可以做到对动态开辟内存大小的调整。

函数原型：

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

①ptr是要调整的内存地址。

②size是调整之后新的大小

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

④这个函数在调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。

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

①原有空间之后有足够大的空间：展开原有内存之后直接追加空间，原来空间数据不变化。

②原有空间之后没有足够大的空间：在堆区的内存中找一个新的空间，并且满足新的大小要求；将原来空间的数据拷贝一份到新的空间；释放旧的空间；返回新的内存空间的起始地址。

③调整失败，返回NULL。


#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(5 * sizeof(int));//申请20个字节
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i + 1;
	}
	//希望将空间调整为40个字节
	int* ptr = (int*)realloc(p, 40);
	if (ptr != NULL)//调整成功
	{
		p = ptr;
		//可以使用40个字节的空间
		for (i = 5; i < 10; i++)
		{
			*(p + i) = i + 1;
		}
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
		free(p);
		p = NULL;
	}
	else//调整失败
	{
		perror("realloc");
		//申请失败，使用20个字节的空间
		free(p);
		p = NULL;
	}
	return 0;
}

调试观察内存和监视

情况3：


//情况3，调整失败
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(INT_MAX);
	if (p == NULL)
		perror("malloc");
	//…………
	return 0;
}

四、常见的动态内存的错误

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


//错误代码
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(INT_MAX);
	*p = 20;//如果p的值是NULL，就会有问题
	free(p);
	return 0;
}
//修改①
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(INT_MAX);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	*p = 20;//如果p的值是NULL，就会有问题
	free(p);
	return 0;
}
//修改②
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
int main()
{
	int* p = (int*)malloc(INT_MAX);
	assert(p);
	*p = 20;//如果p的值是NULL，就会有问题
	free(p);
	return 0;
}

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

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

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


#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		return 1;
	}
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*p = i + 1;
		p++;
	}
	free(p);//这里的p不再是动态申请的内存的起始位置
	p = NULL;
	return 0;
}//程序崩了

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

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