为什么存在动态内存分配？
内存可以这样开辟：
1. int val = 20;//在栈空间上开辟4个字节 2. 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函数用来释放动态开辟的内存：释放的是内存，不是指针，指针并没有被释放，指针仍然指向原来的存储空间。指针是一个变量，只有程序结束时才被销毁。释放了内存空间后，原来指向这块空间的指针还是存在！只不过现在指针指向的内容是垃圾，是未定义的，所以说是垃圾。因此，释放内存后把指针指向NULL，防止指针在后面不小心又被解引用了。
使用free时要注意：
（1）如果参数p指向的空间不是动态开辟的，那么free函数的行为是未定义的
（2）如果参数p是NULL指针，则函数什么事都不做
malloc和free的头文件都是stdlib.h
1. #define _CRT_SECURE_NO_WARNINGS 1 2. #include<stdio.h> 3. int main() 4. 5. { 6. int a = 10; 7. int* p = &a; 8. 9. //free只能free堆上的空间，而&a在栈区，会报错 10. free(p);//err 11. 12. return 0; 13. }
calloc
void *calloc(size_t num,size_t size)
为num个大小为size的元素分配一块内存，并将申请到的每个字节都初始化为零
比较malloc和calloc：
(1)malloc只有一个参数---字节数size，calloc有两个参数---元素个数num、每个元素的字节数size
(2)malloc动态内存申请空间成功后，不会初始化，calloc会将每个字节都初始化为0
1. #define _CRT_SECURE_NO_WARNINGS 1 2. #include<stdio.h> 3. #include<stdlib.h> 4. int main() 5. { 6. int* p = (int*)malloc(40); 7. //int* p = (int*)calloc(10, sizeof(int)); 8. 9. if (p == NULL) 10. { 11. return 1; 12. } 13. int i = 0; 14. for (i = 0; i < 10; i++) 15. { 16. printf("%d\n", *(p + i)); 17. } 18. 19. free(p); 20. p = NULL; 21. 22. return 0; 23. }
当把上述代码改成calloc动态内存分配时
1. #define _CRT_SECURE_NO_WARNINGS 1 2. #include<stdio.h> 3. #include<stdlib.h> 4. int main() 5. { 6. //int* p = (int*)malloc(40); 7. int* p = (int*)calloc(10, sizeof(int)); 8. 9. if (p == NULL) 10. { 11. return 1; 12. } 13. int i = 0; 14. for (i = 0; i < 10; i++) 15. { 16. printf("%d\n", *(p + i)); 17. } 18. 19. free(p); 20. p = NULL; 21. 22. return 0; 23. }
因此，如果对申请的内存空间的内容要求初始化，可以使用calloc函数.
有时会发现过去申请的空间太小了，有时候又会觉得申请的空间过大了，为了合理的使用内存， 对动态开辟内存的大小做灵活的调整，可以使用 realloc 函数。
realloc
void* realloc (void* ptr, size_t size);
（1）ptr 是要调整的内存地址
（2）size 调整之后新大小
（3）返回值为调整之后的内存起始位置
（4）这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到“新”的空间
（5）realloc在调整内存空间时存在两种情况
情况1：原有空间之后有足够大的空间
要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化
情况2：原有空间之后没有足够大的空间
原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来 使用。这样函数返回的是一个新的内存地址。
由于realloc有可能申请失败，返回空指针，就不能直接用原来的指针接收，否则已经保存在原来的空间上的数据就无法维护了，因此需要用新的指针接收新空间地址，如果新空间申请成功，就把新指针赋给原来的指针。
对于情况1：先申请了40个字节，发现申请的空间不够用时，再申请20个字节
1. #define _CRT_SECURE_NO_WARNINGS 1 2. #include<stdio.h> 3. #include<stdlib.h> 4. int main() 5. { 6. //先申请10个int的空间 7. int* p = (int*)malloc(10*sizeof(int)); 8. 9. if (p == NULL) 10. { 11. perror("main"); 12. return 1; 13. } 14. int i = 0; 15. for (i = 0; i < 10; i++) 16. { 17. *(p + i) = 0; 18. } 19. 20. //这里需要p指向的空间更大，还需要2个int的空间，需要realloc重新调整空间，调整后的大小为12 * sizeof(int) 21. int* ptr = realloc(p, 12 * sizeof(int)); 22. 23. if (ptr != NULL) 24. { 25. p = ptr; 26. } 27. 28. //使用申请的内存空间 29. 30. //使用完毕释放 31. free(p); 32. p = NULL; 33. 34. 35. return 0; 36. }
VS2013 F10-监视，p指向的空间之后的空间够存放realloc需要申请的空间时，realloc申请的内存空间会在p申请的内存之后追加，从监视可以看出此时p指向的内存起始地址(0x006c54e0) = ptr指向的内存起始地址(0x006c54e0)
对于情况2：先申请了40个字节，发现申请的空间不够用时，再申请20000个字节
1. #define _CRT_SECURE_NO_WARNINGS 1 2. #include<stdio.h> 3. #include<stdlib.h> 4. int main() 5. { 6. //先申请10个int的空间 7. int* p = (int*)malloc(10 * sizeof(int)); 8. 9. if (p == NULL) 10. { 11. perror("main"); 12. return 1; 13. } 14. int i = 0; 15. for (i = 0; i < 10; i++) 16. { 17. *(p + i) = 0; 18. } 19. 20. //这里需要p指向的空间更大，还需要10000个int的空间，需要realloc重新调整空间,调整后的大小为10010 * sizeof(int) 21. int* ptr = realloc(p, 10010* sizeof(int)); 22. 23. if (ptr != NULL) 24. { 25. p = ptr; 26. } 27. 28. //使用申请的内存空间 29. 30. //使用完毕释放 31. free(p); 32. p = NULL; 33. 34. 35. return 0; 36. }
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);
