为什么存在动态内存分配？
内存可以这样开辟：
int val = 20;//在栈空间上开辟4个字节
char arr[10] = {0};//在占空间上开辟10个字节的连续空间
但是这样的开辟空间方式有两个特点：
1.空间开辟大小是固定的
2.数组在声明时，必须制定数组的长度，它所需要的内存会在编译时分配。
如果所需空间大小在程序运行时才能确定，那么数组编译时开辟空间的方式就不能应对这样的需求，这时就需要动态内存开辟
动态内存开辟申请的空间位于堆区
malloc
void* malloc(size_t size)
向内存申请一块连续可用的空间，并返回指向这块空间的指针
（1）如果开辟成功，则返回一个指向开辟空间的指针
（2）如果开辟失败，则返回一个NULL指针，因此malloc的返回值必须要做检查
（3）返回值的类型是void* ，因此malloc函数并不知道开辟空间的类型，需要使用者在使用时决定类型
（4）如果参数size为0，malloc的行为是标准未定义的，取决于编译器
free
void free(void* ptr）
free函数用来释放动态开辟的内存
（1）如果参数ptr指向的空间不是动态开辟的，那么free函数的行为是未定义的
（2）如果参数ptr是NULL指针，则函数什么事都不做
malloc和free的头文件都是stdlib.h
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
int a = 10;
int* p = &a;
//free只能free堆上的空间，而&a在栈区，会报错
free(p);//err
return 0;
}
calloc
void *calloc(size_t num,size_t size)?
为num个大小为size的元素分配一块内存，并将申请到的每个字节都初始化为零
比较malloc和calloc：
(1)malloc只有一个参数---字节数size，calloc有两个参数---元素个数num、每个元素的字节数size
(2)malloc动态内存申请空间成功后，不会初始化，calloc会将每个字节都初始化为0
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
int main()
{
int* p = (int*)malloc(40);
//int* p = (int*)calloc(10, sizeof(int));
if (p == NULL)
{
return 1;
}
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d\n", *(p + i));
}
free(p);
p = NULL;
return 0;
}
?当把上述代码改成calloc动态内存分配时
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
int main()
{
//int* p = (int*)malloc(40);
int* p = (int*)calloc(10, sizeof(int));
if (p == NULL)
{
return 1;
}
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d\n", *(p + i));
}
free(p);
p = NULL;
return 0;
}
?因此，如果对申请的内存空间的内容要求初始化，可以使用calloc函数.
有时会发现过去申请的空间太小了，有时候又会觉得申请的空间过大了，为了合理的使用内存， 对动态开辟内存的大小做灵活的调整，可以使用?realloc 函数。
realloc
void* realloc (void* ptr, size_t size);
（1）ptr 是要调整的内存地址
（2）size 调整之后新大小
（3）返回值为调整之后的内存起始位置
（4）这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到“新”的空间
（5）realloc在调整内存空间时存在两种情况
? ? ? ? 情况1：原有空间之后有足够大的空间
? ? ? ? ? ? ? ? ? ? 要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化
? ? ? ? 情况2：原有空间之后没有足够大的空间
? ? ? ? ? ? ? ? ? ?原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来 使用。这样函数返回的是一个新的内存地址。
由于realloc有可能申请失败，返回空指针，就不能直接用原来的指针接收，否则已经保存在原来的空间上的数据就无法维护了，因此需要用新的指针接收新空间地址，如果新空间申请成功，就把新指针赋给原来的指针。?
对于情况1：先申请了40个字节，发现申请的空间不够用时，再申请20个字节
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
int main()
{
//先申请10个int的空间
int* p = (int*)malloc(10*sizeof(int));
if (p == NULL)
{
perror("main");
return 1;
}
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = 0;
}
//这里需要p指向的空间更大，还需要2个int的空间，需要realloc重新调整空间，调整后的大小为12 * sizeof(int)
int* ptr = realloc(p, 12 * sizeof(int));
if (ptr != NULL)
{
p = ptr;
}
//使用申请的内存空间
//使用完毕释放
free(p);
p = NULL;
return 0;
}VS2013? F10-监视，p指向的空间之后的空间够存放realloc需要申请的空间时，realloc申请的内存空间会在p申请的内存之后追加，从监视可以看出此时p指向的内存起始地址(0x006c54e0) = ptr指向的内存起始地址(0x006c54e0)
?
对于情况2：先申请了40个字节，发现申请的空间不够用时，再申请20000个字节
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
int main()
{
//先申请10个int的空间
int* p = (int*)malloc(10 * sizeof(int));
if (p == NULL)
{
perror("main");
return 1;
}
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = 0;
}
//这里需要p指向的空间更大，还需要10000个int的空间，需要realloc重新调整空间,调整后的大小为10010 * sizeof(int)
int* ptr = realloc(p, 10010* sizeof(int));
if (ptr != NULL)
{
p = ptr;
}
//使用申请的内存空间
//使用完毕释放
free(p);
p = NULL;
return 0;
}
?
VS2013? F10-监视，p指向的空间之后的空间不够存放realloc需要申请的空间时，realloc在堆上重新申请一块内存空间，从监视可以看出p指向的内存起始地址(0x00b354e0) != ptr指向的内存起始地址(0x00b3b008)
realloc申请空间总结为：空间够申请时直接申请，不够申请时：
（1）重新申请一块空间
（2）把原来空间的内容拷贝到新空间里面去
（3）释放原来的空间
（4）返回新空间起始地址
当realloc的第一个参数，需要调整的内存的地址为NULL时，realloc就相当于malloc,直接在堆区开辟size个字节大小的空间。如：
int *p = (int*)realloc(NULL,40);注意
malloc、calloc、realloc申请内存空间时前面都要加强转