1.为什么会存在动态内存分配
根据我们学过的知识，要在内存中开辟一个空间，有两种方式：
int c = 10;//创建一个变量 int arr[10] = { 0 };//创建一个数组
但是上述开辟空间的方式有两个局限性：
1.空间开辟的大小是固定的
2.数组在声明的时候，必须指定数组的长度，他所需要的内存在编译时分配
但是有时候，我们只有在运行程序的时候，才能知道自己需要多大的空间，这时候空间已经开辟好了，不能再改变了，有可能大了，也有可能小了，所以上述开辟方式可能会在我们使用的时候带来极大的不便，这就是我们需要动态内存开辟的原因，动态内存管理会根据我们的需要，对开辟的空间进行放大和缩小。
2.动态内存函数的介绍
动态内存管理函数有4个：malloc、calloc、realloc、free
2.1 malloc和free
void* malloc( size_t size );
这个函数向内存申请一块连续的空间，并返回指向这块空间的指针。
int main() { int arr[10] = { 0 }; int* p = (int*)malloc(40); return 0; }
上述代码中，我们用数组申请了10个整型的空间，也可以用malloc向内存申请10个整型的空间（40个字节） 。
注意我们将这块空间的地址赋给指针p时，指针p是int*型，而malloc函数的返回类型是void*，所以要强制类型转化为int*。
这样我们就用malloc申请了空间，下面我们就可以直接使用了吗？
可能不行，因为malloc申请空间也是会失败的：
如果开辟成功，则返回一个指向开辟好的空间的指针。
如果开辟失败，则返回一个NULL指针
因此malloc的返回值一定要做检查：
#include<stdio.h> #include<stdlib.h> int main() { int* p = (int*)malloc(40); if (p == NULL) { perror("malloc");//打印错误信息 return 1; } //开辟成功 int i = 0; for (i = 0; i < 10; i++) { printf("%d ", *(p + i)); } return 0; }
用if语句判断是否开辟成功，如果开辟失败，则用perror函数打印错误信息，如果开辟成功，则打印出来。（注意使用perror时，要包含头文件<stdlib.h>）
下面我们再来讲一下malloc函数在内存中开辟的空间的具体体现：
之前我们学过，内存中分为栈区、堆区、静态区。栈区存放的是局部变量和形式参数等，静态区存放的是全局变量和静态变量等，那堆区存放的是什么呢？
就是动态内存开辟。
malloc函数申请的空间在堆区，指针变量p开辟的空间在栈区，存放所申请空间的地址。
malloc申请到空间后，直接返回这块空间的地址，不初始化空间的内容，所以上述代码打印的结果是：
而当程序退出时，malloc申请的内存空间不会主动还给操作系统，这时候就需要用free函数了：
#include<stdio.h> #include<stdlib.h> int main() { int* p = (int*)malloc(40); if (p == NULL) { perror("malloc");//打印错误信息 return 1; } //开辟成功 int i = 0; for (i = 0; i < 10; i++) { printf("%d\n", *(p + i)); } //释放空间 free(p); p = NULL; return 0; }
当free释放掉malloc申请的内存空间后，此时栈区的指针变量p还在啊，它里面还从存放着已经释放掉空间的地址，如果我们不对它进行处理，那p就成了野指针，所以在free(p)后面还令p=NULL。
我们在使用free函数时也要注意，不是动态内存开辟的空间不能用free函数释放，如下面的写法就是错误的：
int p = 0; int* ptr = &p; free(ptr);//error
2.2 calloc
void* calloc( size_t num, sizr_t size )
calloc函数的功能是为num个大小为size的元素开辟一块空间，并且把空间的每个字节初始化为0。
与函数malloc函数的区别是calloc函数会在返回前将申请的空间的每一个字节初始化为0。
看下面一段代码：
#include<stdio.h> #include<stdlib.h> int main() { int* p = (int*)calloc(40, sizeof(int)); if (p == NULL) { perror("calloc\n"); return 1; } //打印数据 int i = 0; for (i = 0; i < 10; i++) { printf("%d ", p[i]); } free(p); p = NULL; return 0; }
运行结果：
我们可以看到calloc函数开辟空间后确实将空间中每个字节初始化为全0
当然，我们也可以来看一下开辟失败的结果：
以上就是calloc函数，它和malloc函数有区别，但是功能差不多，下面我们来讲最最重要的realloc函数：
2.3 realloc
realloc函数让动态内存管理更加灵活。
有时候我们发现申请的空间太小了，有时候我们又会觉得申请的空间太小了，那为了合理利用空间，我们一定会对内存的大小进行调整，那realloc函数就可以做到对动态开辟内存大小的调整。
vioe* realloc( void* ptr,size_t size )
ptr是要调整的内存地址，size是调整之后的大小 。
realloc函数的返回值是调整之后的内存起始地址，这个地址有可能和之前开辟空间的地址一样，也有可能是一个新的地址，为什么这么说呢？
这就要提到realloc函数调整空间的两种情况了。
假设我们已经用malloc函数开辟了40个字节的空间，但是我们用的时候觉得不够了，需要再增加40个字节的空间，此时要用realloc将空间大小调整为80个字节，但是realloc在调整时会出现如下两种情况：
下面来看一段代码：
#include<stdio.h> #include<stdlib.h> int main() { int* p = (int*)malloc(40); if (p == NULL) { perror("malloc"); return 1; } //初始化1~10 int i = 0; for (i = 0; i < 10; i++) { p[i] = i + 1; } //增加空间 p = realloc(p, 80); free(p); p = NULL; return 0; }
上述代码中，用p直接来接收realloc的返回地址行不行？
当然不行，要知道realloc函数开辟空间也会失败的，要是开辟成功了，我们用p接收可以，但是要是开辟失败了，这时realloc函数就会返回一个空指针NULL，那此时我们malloc函数开辟的空间的起始地址也是p啊，里面还存放着10个值呢？要是用p接收了空指针，我们这些数据该怎么办？
所以最好为realloc函数返回的新空间的起始地址重新创建一个指针变量ptr，经过判断后再将ptr赋给p:
#include<stdio.h> #include<stdlib.h> int main() { int* p = (int*)malloc(40); if (p == NULL) { perror("malloc"); return 1; } //初始化1~10 int i = 0; for (i = 0; i < 10; i++) { p[i] = i + 1; } //增加空间 int*ptr = (int*)realloc(p, 80); if (ptr != NULL) { p = ptr; ptr = NULL; } else { printf("realloc"); return 1; } //打印数据 for (i = 0; i < 20; i++) { printf("%d\n", p[i]); } //释放空间 free(p); p = NULL; return 0; }
打印结果（可以看到前10个数据还在，后面又开辟了10个int型大小的空间）：
以上就是使用realloc函数增加空间，要想减少空间的话，将传给size的值变小点就行了。
还有一点，要是传给realloc函数参数ptr的是空指针NULL，此时realloc函数和malloc函数的功能一样。
以上就是动态内存管理的4个函数的介绍。
3.常见的动态内存错误
3.1 对NULL指针的解引用操作
int main() { int* p = (int*)malloc(INT_MAX); *p = 20;//如果p是NULL，就会出现问题 free(p); return 0; }
这个我们上文也讲过，要对p进行判断，是不是空指针，如果不是再使用。
3.2 对动态开辟空间的越界访问
#include<stdio.h> #include<stdlib.h> int main() { int* p = (int*)malloc(40); if (p == NULL) { perror("malloc"); return 1; } int i = 0; for (i = 0; i < 20; i++) { p[i] = i + 1;//开辟了10个整型，访问20个整型，越界访问了 } free(p); p = NULL; return 0; }
3.3 对非动态开辟内存使用free释放
上文中讲过：
int p = 0; int* ptr = &p; free(ptr);//error
3.4 使用free释放一块动态开辟内存的一部分
#include<stdio.h> #include<stdlib.h> int main() { int* p = (int*)malloc(40); if (p == NULL) { perror("malloc"); return 1; } int i = 0; for (i = 0; i < 5; i++) { *p = i ; p++; } free(p); p = NULL; return 0; }
上述代码中，我们使用了开辟的空间中的前5个元素，但是注意在使用后进行p++，那当我们运行完，p指向的就是第5个元素所在空间的地址，此时再用free释放，释放的是第5个元素后面的空间，这样程序会崩溃，也就是说，不能使用free释放一块动态开辟内存的一部分。
3.5 对同一块动态内存多次释放
#include<stdio.h> #include<stdlib.h> int main() { int* p = (int*)malloc(40); if (p == NULL) { perror("malloc"); return 1; } free(p); // free(p); p = NULL; return 0; }
我们在写代码的时候很可能出现，前面已经对这块内存释放过了，后面忘记了，又释放了一次，这时就出现错误了，所以最好养成一个习惯，就是在每次释放之后，将p置为NULL，这样即使重复释放，后面的free也没有任何作用。
#include<stdio.h> #include<stdlib.h> int main() { int* p = (int*)malloc(40); if (p == NULL) { perror("malloc"); return 1; } free(p); p = NULL; free(p); p = NULL; return 0; }
