动态内存分布——malloc，calloc，realloc，free的使用。以及关于动态内存的常见错误。

我们知道内存的使用方式，可以在栈区，静态区，堆区，申请空间来储存变量。

但是他们这些内存区所存储的东西是不一样的。

局部变量 函数的形式参数	栈区
动态内存分配申请的空间 malloc，calloc，realloc，	堆区
全局变量， 静态变量， static修饰的变量	静态区

创建一个变量：

int a=10；int arr[]={0};——局部变量——栈区；

int a=10；int arr[]={0};——全局变量——静态区；

但是面两种申请的空间都是固定的，例如我们在使用数组的时候，有时候发现数组的申请的空间小了，又回去改数组的大小，改了之后又发现用不完，就回给我们的空间造成浪费，数组而不能达到随心所欲的修改申请给我们带来不便。这就是我们今天学习的动态内存分布就可以很好的解决相这个问题，当我们的申请的空间小了，我们可以直接扩充，用不完的可以直接减少。

1.malloc

头文件： #include<stdlib.h>

函数框架：void*malloc(size_t size)。

返回值：函数的返回类型位空指针类型，可根据具体的申请的和需要强行转换指针类型，返回的指针指向申请的空间的是首地址。

参数：函数的参数是一个无符号整型数字（size_t  size），代表申请空间的大小，单位为字节。

如果申请成功函数返回申请在堆区空间的地址，如果申请不成功，就会返回NULL（空指针）。

实例：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(sizeof(int) * 10);//申请了一个可以存放10个int类型的空间；
	if (p == NULL)//判断是否申请失败，申请失败会返回空指针（NULL）.
	{
		printf("申请失败\n");
	}
	else
	{
		printf("申请成功\n");
	}
	return 0;
}

 这里申请成功了

 让我们看一下申请不成功的情况

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(100000000000000000*10000000000000000000);//申请了一个非常大的空间，
																   //已经超出我们堆区的最大存储空间，
																   //肯定会申请失败；
	if (p == NULL)//判断是否申请失败，申请失败会返回空指针（NULL）.
	{
		printf("申请失败\n");
	}
	else
	{
		printf("申请成功\n");
	}
	return 0;
}

接下来我们看一下malloc申请空间的使用：

看代码：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(sizeof(int)*10);//申请可以存放10个int型变量的空间；
	if (p == NULL)//判断是否申请失败，申请失败会返回空指针（NULL）.
	{
		printf("申请失败\n");
		return 0;//如果申请失败，我们程序就直接退出，因为申请失败也没有必要进行操作；
	}
	else
	{
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			*(p + i) = i;//申请的10个空间，赋值0——9；
		}
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p+i));//证明我们我们的数字已经存进去，打印出我们存进去的数字。
	    }
	}
	free(p);//当我们的动态申请的空间不再使用的时候，就应该还给操作系统，所以就是用free，对申请的空间释放。
	p = NULL;//但是我们申请的空间是还给操作系统了，但是指针 p 仍旧可以找到那块空间，所以我们把 p赋值成空指针，将指针 p 与空间完全断开联系。
	          
	return 0;
}

关于free：

malloc与free，是成对使用的。 

2.calloc

头文件:#include<stdlib.h>

函数框架：void*calloc（size_t num,size_t size）;

calloc的功能与malloc基本一样，也是从堆区申请一块空间，但是区别就在于calloc会在返回地址之前把申请的空间全部赋值为0；

参数：size_t num——无符号整形数，代表申请空间的个数，size_t size——无符号整形数，代表

申请每个空间的大小，单位为字节。

返回值：函数的返回类型位空指针类型，可根据具体的申请的和需要强行转换指针类型，返回的指针指向申请的空间的是首地址。

如果申请成功函数返回申请在堆区空间的地址，如果申请不成功，就会返回NULL（空指针）。

实例2.

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)calloc(10,sizeof(int));//申请可以存放10个int型变量的空间；
	if (p == NULL)//判断是否申请失败，申请失败会返回空指针（NULL）.
	{
		printf("申请失败\n");
		return 0;//如果申请失败，我们程序就直接退出，因为申请失败也没有必要进行操作；
	}
	else//申请成功开始使用
	{
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));//查看在为赋值的时候申请的空间里面存储是不是0；
			*(p + i) = i;//申请的10个空间，赋值0——9；
		}
		printf("\n");
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));//证明我们的数字已经存进去，打印出我们存进去的数字。
		}
	}
	free(p);
	p = NULL;//用完别忘记释放哦。
	return 0;
}

3.realloc

realloc函数使我们动态内存管理更加灵活。

有时会发现过去申请的空间太小了，有时候我又会觉得申请的空间太大了，那为了合理的内存，我们呢一定会对内存进行灵活的调整，realloc就可以做到对内存大小的调整。

函数原型：void* realloc(void*ptr,size_t size)

参数：void*ptr ，ptr为要调整的空间的地址，size_t size为调整之后的新大小。

返回值：调整之后的内存的起始位置，

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

realloc使用实例：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)calloc(10, sizeof(int));//申请可以存放10个int型变量的空间；
	if (p == NULL)//判断是否申请失败，申请失败会返回空指针（NULL）.
	{
		printf("申请失败\n");
		return 0;//如果申请失败，我们程序就直接退出，因为申请失败也没有必要进行操作；
	}
	else//申请成功开始使用
	{
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));//查看在为赋值的时候申请的空间里面存储是不是0；
			*(p + i) = i;//申请的10个空间，赋值0——9；
		}
		printf("\n");
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));//证明我们的数字已经存进去，打印出我们存进去的数字。
		}
	}
	printf("\n");
	//这时我们发现内存不够
	int* p1 = (int*)realloc(p, sizeof(int) * 15);//我们将申请空间扩大到可以存放15个int型数字。
	if (p1 == NULL)
	{
		printf("申请失败");
		return 0;
	}
	for (int i = 10; i < 15; i++)
	{
		*(p1 + i) = i;//将新申请的空间赋值10——14；
	}
	for (int i = 0; i < 15; i++)
	{
		printf("%d ", *(p1 + i));
	}
	free(p1);
	p1 = NULL;

	return 0;
}

关于realloc的注意：

如果原空间之后有足够的空间就可以直接追加，然后返回调整之后的空间的起始位置地址；

如果原空间后面没有足够的空间可以用来追加，则realloc就会重新找一个新的内存区域，将元数据拷贝过去再追加，最后返回新空间的起始位置地址；

要用一个新的指针变量来接受realloc函数的返回值；

关于realloc在内存追加空间的时候，后面没有足够的大小用来追加会重新找一个新的内存区域，将元数据拷贝过去再追加，最后返回新空间的起始位置地址；

实例：

#include<stdio.h>
#include<stdlib.h>
int main()//(1)后面有足够的空间追加；
{
	int* p = (int*)malloc(1);//申请可以存放1个字节的空间；
	if (p == NULL)//判断是否申请失败，申请失败会返回空指针（NULL）.
	{
		printf("申请失败\n");
		return 0;//如果申请失败，我们程序就直接退出，因为申请失败也没有必要进行操作；
	}
	printf("%p\n", p);
	int* p= (int *)realloc(p, 2);//追加一个字节，后共2个字节；
	printf("%p\n", p);
	free(p);
	p=NULL;
	return 0;
}

#include<stdio.h>
#include<stdlib.h>
int main()//(1)后面没有足够的空间追加；
{
	int* p = (int*)malloc(1);//申请可以存放1个字节的空间；
	if (p == NULL)//判断是否申请失败，申请失败会返回空指针（NULL）.
	{
		printf("申请失败\n");
		return 0;//如果申请失败，我们程序就直接退出，因为申请失败也没有必要进行操作；
	}
	printf("%p\n", p);
	int* p= (int *)realloc(p, 10000);//追加字节，后共10000个字节；
	printf("%p\n", p);
	free(p);
	p=NULL;
	return 0;
}

常见的动态内存的错误

1.对空指针解引用

void test()
{
	int* p = (int*)malloc(1000000000 * 10000000*10000000);//由于申请的空间过大而申请失败返回空指针；
	*p = 20;//当p为NULL时就会有问题；
	free(p);
	p = NULl;

}

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

int* p = (int*) = malloc(sizeof(int) * 5);//申请5个int的空间
if (p = NULl)
{
	exit;
}
for (int i = 0; i < 10; i++)//却访问10个int的空间
{
	*(p + i) = i;
}

3.对非动态开辟的空间进行free释放

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

4.使用free释放一块空间的一部分

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

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

void Get()
{
	int*p = (char*)malloc(100);
	free(p);
	free(p);
}

6.动态内存忘记释放

void Get(char* p)
{
	p = (char*)malloc(100);
}
void test()
{
	char* str = NULL;
	Get(str);//以变量的方式传参；无法做到str的修改；
	strcpy(str, "hello");
	printf(str);
}

运行的时候程序会崩溃，而且存在内存泄漏；

str以值的形式传参给p；p是Get的函数的形参，只能在函数内部有效，等Get函数返回之后，动态开辟的空间还未释放，并且无法找到，就会存在内存泄漏。