‍1.为什么存在动态内存分配？

通常：
int a = 20;	//在栈空间是哪个开辟四个字节
char arr[10] = {0}; 	//在栈空间上开辟10个字节的连续空间；
但是，上述开辟的内存的方式有两个缺点：

• 空间开辟的大小是固定的；
• 数组在声明的时候，必须指定数组的长度，和它所需要的内存，以至于在编译时系统分配空间；
• 然而，对于空间的需求，不仅仅是上述的情况；有时候我们需要的空间大小在程序运行的时候才能知道，那数组在定义是给定的固定大小的空间就不能满足需求了，这时候我们就哟尝试动态内存开辟！

请看栈区、堆区、静态区在内存空间中分布

‍2. 动态内存函数的介绍：

2.1 malloc() and free() 函数

malloc函数原型：

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

1. 如果开辟成功，则返回一个指向开辟好空间的指针；
2. 如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查；
3. malloc的返回值类型是void*, 所以malloc函数并不知道开辟空间的类型，具体是什么类型的空间由使用者自己来决定；
4. 如果参数size为0,malloc的行为是标准是未定义的，具体取决于编译器；

C语言提供了另一个函数free()，专门是用来做动态内存的释放和回收的;

函数原型：

free()函数用来释放动态开辟的内存；

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

用法：

int main()
{
    
	//假设开辟10int类型的空间,总大小为10*szeof(int)
	int arr[10]; //栈区上开辟
//动态内存开辟
	int* p = (int*)malloc(10*sizeof(int));
//malloc的返回值为void* ,此时我们无法使用，把它换成int*
//使用开辟的空间
//先判断是否开辟成功
	if(p == NULL)
	{
    
		perror(); //打印错误
		return 0;
	}
	//使用
	int i = 0;
	for(i = ;i < 10; i++)
	{
    
		*(p+i) = i;
	}
	for(i = 0; i < 10; i++)
	{
    
		printf("%d\n",p[i]);
	}
	//使用完释放空间
	free(p);
	p = NULL;//手动值为空；
	return 0;
}

2.2 calloc()函数

函数原型：

1. 函数的功能是为num个大小为size的元素开辟一块空间，并且把空间的每个字节初始化为0；
2. 与函数malloc的区别在于：calloc会在返回地址之前把申请空间的每个元素初始化为0；

2.3 realloc()函数

函数原型：

1. *memory 是要调整的内存地址；
2. size_t size是调整之后的大小；
3. 返回值为调整之后的内存起始地址；
4. realloc函数会在调整原内存空间大小的基础上，还会将原来的内存中的数据移动到新的空间；
5. realloc在调整内存空间的时候存在两个情况：
   （1）原有空间之后有足够大的空间,则在原空间后面开辟一段新空间，把整个空间的地址返回；
   （2）原有空间之后没有足够大的空间，则realloc函数会拷贝原来的内存空间的值，然后寻找到一块足够大的空闲空间，然后把原来的内存空间存放的数据拷贝在此，然后再往后开辟新空间，然后返回新的内存空间的地址；

• 注：如果realloc函数一直没有找到合适的空间，则会返回空指针；所以我们一般不把realloc函数的返回值直接赋值给指向原来的内存空间的指针，而是创建一个临时指针来存放realloc函数的返回值，然后判断其是否为空，若不为空，再赋值给指向原空间地址的指针；

6. realloc函数的出现让动态内存管理更加灵活；
7. 有时我们会发现过去申请的空间小了，有时有觉得申请的空间太大了；为了开辟合适的空间，我们一定会对内存的大小做灵活的调整；而realloc函数就可以做到对动态开辟内存大小的调整；

具体使用：

int main()
{
    
	int* p = calloc(110,sizeof(int));
	if(*p == NULL)
	{
    
		perror(); 	//打印报错
		return 1;
	}
	//使用动态开辟的地址
	int i = 0;
	for(i=0;i<10;i++）
	{
    
		*(p=i) = i;
	} 	
 //此时需要p指向更大的空间时，需要20个int的空间；
	int* ptr = realloc(p,20*sizeof(int));
	if(ptr != NULL)
	{
    
		p = ptr;
	}
	free(p);
	p = NULL;
}

‍3. 常见的动态内存错误

3.1 对NULL指针解引用操作

错误示范：

int main()
{
    
	int* p = (int*)malloc(100000000000);		//动态申请开辟的空间过大，不予开辟
	int i = 0;
	for(i = 0;i < 10;i++)
	{
    
		*(p+i) = i;
	}
	free(p);
	p = NULL;
	return 0;
}

解决：对动态开辟的内存指针进行判断，即对malloc函数的返回值进行判断；

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

错误示范：

int main()
{
    
	int* p = (int*)malloc(10*sizeof(int));
	if( p == NULL)
	{
    
		perror();
		return 1;
	}
	// 越界访问
	int i = 0
	for(i = 0; i< 40;i++)  //只开辟了40个字节空间，而不是开辟了40个元素；
	{
    
		*(p+i) = i;
	}
	free(p);
 	p =NULL;
	return 0;
}

3.3 使用free()释放非动态开辟空间

错误示范：

int main()
{
    
	int arr[10] = {
    0};	//在栈区上开辟空间
	int* p = arr;
	free(p);  //错误
	p=NULL;
}

3.4 使用free释放动态内存中的一部分

错误示范：

int main()
{
    
	int* p = (int*)malloc(10*sizeof(int));
	if( p= NULL )
	{
    
		return 1;
	}
	int i = 0;
	for(i = 0;i<5;i++)
	{
    
		*p++ = i; 
		//此时pn不在指向动态开辟的空间起始位置，之后释放只是释放动态开辟空间的一部分；
	}
	free(p);
	p = NULL;
}

3.5 对同一块动态开辟的空间多次释放

错误示范：

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

3.6 动态开辟的空间忘记释放

错误示范：

void test()
{
    
	int* p = (int*)malloc(100);
	if( p == NULL)
	{
    
		return;
	}
}
int main()
{
    
	test();
	return 0;
}

p是局部变量，跳出函数后，p的生命周期结束了；而如果没有释放动态开辟的空间，之后在不能找到在test函数动态开辟的空间；久而久之就会造成内存泄露；

• 总结：malloc动态开辟的空间，2种回收方式：
  （1）主动free()函数回收
  （2）整个程序结束；