动态内存分布——malloc，calloc，realloc，free的使用。以及关于动态内存的常见错误。
我们知道内存的使用方式，可以在栈区，静态区，堆区，申请空间来储存变量。
但是他们这些内存区所存储的东西是不一样的。
| 局部变量 函数的形式参数 |
栈区 |
| 动态内存分配申请的空间 malloc，calloc，realloc， |
堆区 |
| 全局变量， 静态变量， static修饰的变量 |
静态区 |
创建一个变量：
int a=10；int arr[]={0};——局部变量——栈区；
int a=10；int arr[]={0};——全局变量——静态区；
但是面两种申请的空间都是固定的，例如我们在使用数组的时候，有时候发现数组的申请的空间小了，又回去改数组的大小，改了之后又发现用不完，就回给我们的空间造成浪费，数组而不能达到随心所欲的修改申请给我们带来不便。这就是我们今天学习的动态内存分布就可以很好的解决相这个问题，当我们的申请的空间小了，我们可以直接扩充，用不完的可以直接减少。
1.malloc
头文件： #include
函数框架：void*malloc(size_t size)。
返回值：函数的返回类型位空指针类型，可根据具体的申请的和需要强行转换指针类型，返回的指针指向申请的空间的是首地址。
参数：函数的参数是一个无符号整型数字（size_t size），代表申请空间的大小，单位为字节。
如果申请成功函数返回申请在堆区空间的地址，如果申请不成功，就会返回NULL（空指针）。
实例：
#include
#include
int main()
{
int* p = (int*)malloc(sizeof(int) * 10);//申请了一个可以存放10个int类型的空间；
if (p == NULL)//判断是否申请失败，申请失败会返回空指针（NULL）.
{
printf("申请失败\n");
}
else
{
printf("申请成功\n");
}
return 0;
} 这里申请成功了
让我们看一下申请不成功的情况
#include
#include
int main()
{
int* p = (int*)malloc(100000000000000000*10000000000000000000);//申请了一个非常大的空间，
//已经超出我们堆区的最大存储空间，
//肯定会申请失败；
if (p == NULL)//判断是否申请失败，申请失败会返回空指针（NULL）.
{
printf("申请失败\n");
}
else
{
printf("申请成功\n");
}
return 0;
} 
接下来我们看一下malloc申请空间的使用：
看代码：
#include
#include
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
函数框架：void*calloc（size_t num,size_t size）;
calloc的功能与malloc基本一样，也是从堆区申请一块空间，但是区别就在于calloc会在返回地址之前把申请的空间全部赋值为0；
参数：size_t num——无符号整形数，代表申请空间的个数，size_t size——无符号整形数，代表
申请每个空间的大小，单位为字节。
返回值：函数的返回类型位空指针类型，可根据具体的申请的和需要强行转换指针类型，返回的指针指向申请的空间的是首地址。
如果申请成功函数返回申请在堆区空间的地址，如果申请不成功，就会返回NULL（空指针）。
实例2.
#include
#include
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
#include
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
#include
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
#include
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.动态内存忘记释放
7.
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函数返回之后，动态开辟的空间还未释放，并且无法找到，就会存在内存泄漏。