一、为什么会存在动态内存管理
我们常见的内存开辟方式：
int a = 10;//在栈区上开辟4个字节的空间 char str[10] = { 1,2,3,4,5,6,7,8,9,10 };//在栈区上开辟10个字节连续的空间
以上的开辟方式有连个特点：
1.空间开辟的大小是固定的；
2.数组在开辟空间时需给定大小；
对于空间的要求不仅仅只是上述两种情况，以通讯录（后期会做介绍）为例，存储联系人信息时，需要向内存申请空间，如果一次性申请很大的空间，联系人很少，就会导致空间的浪费，如果一次性申请很小的空间，联系人很多，就会导致空间不够；此时就利用到动态内存了，需要多少个字节的空间，就向内存申请多少，实现了内存空间的有效利用。
二、动态内存函数的介绍
1.malloc和free函数
malloc函数 ：
函数原型：void *malloc( size_t size );
头 文 件：<stdlib.h>
函数功能：向内存申请一块连续可用的空间，并返回指向这块空间的指针
参数解读：size_t size: 向内存申请size个字节的空间；
注意事项：
1. 如果开辟成功，则返回一个指向开辟好空间的指针。
2. 如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
3. 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定（意为：将返回的指针强转类型）。
4. 如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器
5. 每次开辟完空间后，都需要对其进行释放；
free函数：
函数原型：void free( void *memblock );
头 文 件：<stdlib.h>
函数功能：用来释放之前开辟的空间；
注意事项：
1. 如果参数 p 指向的空间不是动态开辟的，那free函数的行为是未定义的。
2. 如果参数 p 是NULL指针，则函数什么事都不做。
3. free之后要将指针置为空；
#include <stdio.h> #include <stdlib.h> int main() { //申请空间 int* ptr = (int*)malloc(40); if (ptr == NULL) { return -1; } //申请成功 int i = 0; for (i = 0; i < 10; i++) { *(ptr + i) = i; } for (i = 0; i < 10; i++) { printf("%d ", *(ptr + i)); } printf("\n"); //释放空间 free(ptr); ptr = NULL;//让ptr找不到那块空间 return 0; }
2.calloc函数
函数原型：void *calloc( size_t num, size_t size );
头 文 件：<stdlib.h>
函数功能：函数的功能是开辟 num 个，大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0；
注意事项：每次开辟完空间后，都需要对其进行释放（free）；
malloc和calloc的区别：
malloc函数只负责在堆区开辟空间，并且返回起始地址，不初始化内存空间；
calloc函数在堆区上申请空间，并且初始化为0，返回起始地址；
malloc和calloc区别代码实现：
#include <stdio.h> #include <stdlib.h> int main() { int* ptr = (int*)calloc(10, sizeof(int)); //申请空间 if (ptr == NULL) { return -1; } //是否初始化？来判断一下 int i = 0; for (i = 0; i < 10; i++) { printf("%d ", *(ptr + i)); } //释放空间 free(ptr); ptr = NULL; return 0; }
#include <stdio.h> #include <stdlib.h> int main() { int* ptr = (int*)malloc(40); //申请空间 if (ptr == NULL) { return -1; } //是否初始化？来判断一下 int i = 0; for (i = 0; i < 10; i++) { printf("%d ", *(ptr + i)); } //释放空间 free(ptr); ptr = NULL; return 0; }
从运行结果来看，calloc函数可以将申请的空间进行初始化，而malloc函数不可以，其打印的结果是随机值；
3.realloc函数
函数原型： void *realloc( void *memblock, size_t size );
头 文 件：<stdlib.h>
函数功能：相比malloc和calloc函数而言，realloc函数会更灵活；
参数解读：
1. memblock 是要调整的内存地址；
2. size 调整之后新大小；
3. 返回值为调整之后的内存起始位置；
4. 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间；
realloc在调整内存空间的是存在两种情况：
1.原有空间之后有足够大的空间 ----直接扩大
2.原有空间之后没有足够大的空间 ----重新找一块新的2倍大的空间，并将原来的数据拷贝过去
举例：
#include <stdlib.h> #include <string.h> int main() { //申请空间 int* p = (int*)calloc(10, sizeof(int)); if (p == NULL) { return -1; } //申请成功，开始赋值 int i = 0; for (i = 0; i < 10; i++) { *(p + i) = i; } //打印数据 printf("增加空间前："); for (i = 0; i < 10; i++) { printf("%d ", *(p + i)); } printf("\n"); //此时需要存入10~19这些数据，就需要增加空间 int* ptr = realloc(p, 20 * sizeof(int)); if (ptr != NULL) { p = ptr; } else { return -1; } for (i = 10; i < 20; i++) { *(p + i) = i; } printf("增加空间后："); for (i = 0; i < 20; i++) { printf("%d ", *(p + i)); } printf("\n"); //释放空间 free(p); p = NULL; return 0; }
三、常见的动态内存错误
1.NULL指针的解引用操作；
2.对动态开辟空间的越界访问；
3.对非动态开辟内存使用free释放；
4.使用free释放一块动态开辟内存的一部分；
5.对同一块动态内存多次释放；
6.动态开辟内存忘记释放（内存泄漏）；
例题1
//请问运行Test 函数会有什么样的结果 #include <stdio.h> #include <stdlib.h> void GetMemory(char* p) { p = (char*)malloc(100); } void Test(void) { char* str = NULL; GetMemory(str); strcpy(str, "hello world"); printf(str); } int main() { Test(); return 0; }
存在的问题：
1. malloc申请的空间，没有释放；
2. malloc开辟的空间是存在形式参数p中的，一旦这段程序运行结束，想要销毁都来不及，所以存在内存泄露；
3. 程序崩溃；
强调：
1.str传给p的时候，是值传递，p是str的临时拷贝，所以当malloc开辟的空间起始地址放在p中的时候，不会影响str。str仍为NULL;
2.当str是NULL，strcpy想把hello world拷贝到str指向的空间时，程序崩溃了。因为NULL指针指向的空间是不能被访问的
例题2
//请问运行Test 函数会有什么样的结果 #include <stdio.h> #include <stdlib.h> char* GetMemory(void) { char p[] = "hello world"; return p; } void Test(void) { char* str = NULL; str = GetMemory(); printf(str); } int main() { Test(); return 0; }
存在的问题：
p数组是局部变量，它的生命周期出大括号结束；虽然str拿到了p数组的地址，但是p数组所在的那块空间已经销毁了，此时str就是野指针了；再对它进行打印就会造成非法访问；
