动态内存管理

1.前言

关于动态内存，在未接触动态内存的时候，我们开辟的空间方法有两种一种是定义一个变量还有一种是创建一个数组但这些开辟空间都是固定的静止的，没有操作的空间，局限性很强，而当你了解了动态内存之后，你的操作空间会变得很大，并且更加灵活。我们的内存分为大致可以分为三部分
分别是栈（局部变量、形式参数） 、堆（动态）、静态区（全局变量、静态变量）

2.为什么会存在动态内存

在知道动态内存之前，我们知道两种开辟空间的方式

int a=10;//开辟了4个字节的空间
int arr[10]={1,2,3,4,5,6,7,8,9,10};//开辟了10个整型的连续的空间

这两种开辟空间的方式有两种特点
1.空间开辟的大小是固定的
2.数组在声明的时候，必须指定数组的长度，它所需要的内存在编译时分配。
在开辟空间的时候，我们有时候根本不知道需要多大的空间，有时候空间开辟大了，但实际根本不需要这么大的空间，没用到的空间就浪费了，有时候空间开辟小了，不满足实际需要的空间。
所以这个时候我们就可以试试动态内存的开辟。

3.动态内存函数的介绍

3.1开辟动态空间的函数malloc函数和calloc函数，free函数用来释放动态开辟的内存。
C语言提供了一个动态内存开辟的函数:
malloc函数

void* malloc(size_t size);

size_t size是需要开辟多大字节的空间
如果开辟成功则返回的是一个指向开辟好空间的指针
开辟失败返回空指针NULL
返回类型是void*泛指针
注：malloc函数开辟完的空间里内容是未初始化的。
代码实现：

#include<stdlib.h>
int main()
{
	int num = 0;
	scanf("%d", &num);
	int* ptr = NULL;//初始化这个ptr整型指针
	ptr =(int*) malloc(num * sizeof(int));
	//判断是否空间开辟成功
	if (ptr == NULL)
	{
		perror("malloc");
	}
	//开辟成功，遍历这个数组
	else
	{
		int i = 0;
		for (i = 0; i < num; i++)
		{
			*(ptr + i) = i;
		}
	}
	//打印
	int i = 0;
	for (i = 0; i < num; i++)
	{
		printf("%d", *(ptr + i));
	}
	//释放动态内存
	free(ptr);
	ptr = NULL;

	return 0;
}

监视下：

在监视下我们发现了ptr确实指向了5个整型大小的空间，并成功的初始化了。

我们现在不帮ptr指向的这5个整型大小的空间初始化，看看原本这由ptr指向的5个整型大小的空间中是什么：

在监视下，我们发现在未帮ptr指向的5个整型大小的空间初始化，它空间中存储的是一些随机值。从而证实我们前面的结论。

上面我们写到了free函数，这个函数一般就是和创造动态内存函数一起用的，这个函数的作用就是释放和回收开辟出来的动态内存，防止内存泄露。

free函数

void free(void* ptr);

free函数主要是去释放和回收动态内存的
1.如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
2.如果参数 ptr 是NULL指针，则函数什么事都不做。
注：我们一般用完free函数去释放或回收动态内存之后，然后将指向之前开辟的动态内存的指针置为空指针NULL，防止那个指针成为野指针。

C语言还有一个开辟动态内存的函数calloc函数

calloc函数

void* calloc(size_t num,size_t size);

size_t num 指的是你需要开辟空间的数量
size_t size 指的是你每开辟一个空间需要的大小(单位为字节)
返回类型为void*泛类型
开辟成功的话，返回的是你所指向开辟成功动态内存空间的指针。
开辟失败的话，返回的是空指针(NULL)
calloc函数与malloc函数的不同有两点
1.参数不一样，calloc函数有两个参数，malloc函数只有一个参数，并且calloc函数参数更细。
2.malloc函数开辟完空间后，空间中的内容是没有初始化的，需要自己去初始化，而calloc函数在开辟完空间后会自动将开辟完的空间的内容全初始化为0.

代码实列

int main()
{
	int num = 0;
	scanf("%d", &num);
	int* ptr = NULL;
	ptr = (int*)calloc(num, sizeof(int));
	if(ptr==NULL)
	{
	perror("calloc");
	}
	free(ptr);
	ptr=NULL;
	return 0;
}

在监视下：

发现我们ptr所指向的开辟5个整型的空间全部都被初始化为0.
小结：
在这两个动态内存函数，两个各有各个的特色，在以后如果需要将开辟完的空间全初始化为0可以用calloc函数，不需要初始化的可以用malloc函数。

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

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

ptr 是要调整的内存地址
size 调整之后新大小
返回值为调整之后的内存起始位置
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间

realloc在调整内存空间的是存在两种情况：
情况1：原有空间之后有足够大的空间
情况2：原有空间之后没有足够大的空间

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

当是情况2 的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。

用代码来实现这两种情况：

第一种情况：

int main()
{
	int* ptr = NULL;
	ptr = (int*)malloc(20);
	if (ptr == NULL)
	{
		perror("malloc");
	}
	//增加空间
	int* ptr1=(int*)realloc(ptr, 40);
	if (ptr1 == NULL)
	{
		perror("realloc");
	}
	if (ptr == ptr1)
	{
		printf("情况1");
	}
	else
	{
		printf("情况2");
	}
	return 0;
}

在监视下：

我们发现这种情况是属于情况1，在原先开辟的空间之后有足够的空间。

第二种情况：

int main()
{
	int* ptr = NULL;
	ptr = (int*)malloc(20);
	if (ptr == NULL)
	{
		perror("malloc");
	}
	//增加空间
	int* ptr1=(int*)realloc(ptr, 1000);
	if (ptr1 == NULL)
	{
		perror("realloc");
	}
	if (ptr == ptr1)
	{
		printf("情况1");
	}
	else
	{
		printf("情况2");
	}
	return 0;
}

在监视下：

我们发现这种情况是属于情况2，在原先开辟的空间后没有足够的空间，所以需要去堆上找一块可以满足需求的连续空间，并且返回的地址也不在是之前的那个地址，而是一个新的地址。

4.常见的动态内存错误

4.1对NULL指针的解引用操作

void test()
{
 int *p = (int *)malloc(INT_MAX/4);
 *p = 20;//如果p的值是NULL，就会有问题
 free(p);
}

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

void test()
{
 int i = 0;
 int *p = (int *)malloc(10*sizeof(int));
 if(NULL == p)
 {
 exit(EXIT_FAILURE);
 }
 for(i=0; i<=10; i++)
 {
 *(p+i) = i;//当i是10的时候越界访问
 }
 free(p);
}

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

void test()
{
 int a = 10;
 int *p = &a;
 free(p);//ok?
}

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

void test()
{
 int *p = (int *)malloc(100);
 p++;
 free(p);//p不再指向动态内存的起始位置
}

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

void test()
{
 int *p = (int *)malloc(100);
 free(p);
 free(p);//重复释放
}

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

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

忘记释放不再使用的动态开辟的空间会造成内存泄漏

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

本章完…