C语言进阶|05动态内存管理数据结构|动态内存分配

我知道的只是“ 肉随便加”和“ 要加多少加多少”　这些词。———— 路飞

阶段2目标：
此阶段开始大量刷题，多多参加编程类竞赛，在实战中锻炼编程思维和本领，并且要在不断复习夯实初阶的基础上，刻意地进行编程思维的训练。学无止境！为了精进编程，可以去学习一切为他服务的课程！

文章图片

目录
本章重点：
一、为什么存在动态内存分配？
二、动态内存函数的介绍
1.malloc函数
2.free函数
3.calloc函数
malloc与calloc的异同：
4.realloc函数（为了更合理的时候内存）
三、常见动态内存错误
1.对NULL指针的解引用操作
2.对动态开辟空间的越界访问
3.对非动态开辟内存使用free释放
4.使用free释放一块动态开辟内存的一部分
5.对同一块动态内存多次释放
6.动态开辟内存忘记释放（内存泄漏）
切记：动态开辟的空间一定要释放，并且正确释放
应用：动态通讯录（优化版）
本章重点： 1.为什么存在动态内存分配
2.动态内存函数的介绍

malloc
free
calloc
realloc

3.常见的动态内存错误
4.几个经典的笔试题
5.柔性数组
一、为什么存在动态内存分配？我们已经掌握的内存开辟方式有：

int val = 20; //在栈空间上开辟四个字节 char arr[10] = {0}; //在栈空间上开辟10个字节的连续空间

但是，上述开辟空间的方式有两个特点：

空间开辟大小是固定的。
数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。

但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。这时候就只能用动态内存开辟了。
二、动态内存函数的介绍我们所知道，我们在堆区实现动态内存分配，利用malloc、calloc、realloc、free函数去进行相应的动态分配操作。如图：

文章图片

1.malloc函数 C语言提供了一个动态内存开辟的函数：

void*malloc(size_t size);

这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。

如果开辟成功，则返回一个指向开辟好空间的指针。
如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。

解释：
1.malloc函数的确官方定义是void* 指针，即：万能型指针。但是我们使用者在使用malloc的时候，需要用具体的类型，来接收，比如：int*、char*
这样写，在解引用取空间中的值得时候，才不会报错；而如果是void* 去接收，解引用时就会有错误，因为编译器面对void*该万能型指针，并不清楚去解引用几个字节。
即：在接收时，需要用具体的数据类型来接收malloc的空间。
”错误“代码：

int main() { //int arr[10] = { 0 }; void* p = malloc(40); return 0; }

正确代码：

int* p = (int*)malloc(40);

2.如果开辟失败，则返回一个NULL指针，即：malloc的返回值一定要做检查。

#include #include int main() { //int arr[10] = { 0 }; //申请空间 int* p = (int*)malloc(40); //开辟了40个字节空间，即：10个int类型空间 //判断是否申请失败 if (p == NULL) { printf("申请失败！"); return -1; } //开辟成功了 //（初始化）/(赋值) int i = 0; for (i = 0; i < 10; i++) { *(p + i) = i; } //释放空间 free(p); return 0; }

我们用*( p + i ) = i; 的方式来赋予空间内以初值，用free函数释放掉指针p维护的10个int类型的空间。而我们调试发现，free掉p之后，仅仅是那10个空间被释放掉了，而指针p仍旧是指向那块空间的地址，构成了一个野指针，所以以后就很危险，需要将p=NULL；让程序更安全。

#include #include int main() { //int arr[10] = { 0 }; //申请空间 int* p = (int*)malloc(40); //开辟了40个字节空间，即：10个int类型空间 //判断是否申请失败 if (p == NULL) { printf("申请失败！"); return -1; } //开辟成功了 //（初始化）/(赋值) int i = 0; for (i = 0; i < 10; i++) { *(p + i) = i; } //释放空间 free(p); p = NULL; return 0; }

2.free函数 C语言提供了另外一个函数free，专门是用来做动态内存的释放和回收的，函数原型如下：

voidfree( void *memblock );

free函数用来释放动态开辟的内存。

如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
如果参数 ptr 是NULL指针，则函数什么事都不做。

解释：
1.如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
2.如果参数 ptr 是NULL指针，则函数什么事都不做。
假如p指针并不是malloc来的，那么对于free(p); 在C语言中是未定义的，即：free也不知道该怎么办了。
总结：
除非 p 本身等于NULL，否则free以后不会等于NULL。因为free不对指针的值做任何操作，而只是试图改变指针指向的一片连续的存储器空间的状态。如果这片存储器空间是malloc或其它兼容方式（例如POSIX库函数strdup）分配过来的，那么会释放这片空间，释放的空间可以之后再次被分配。如果指针本来就等于NULL，则调用free不会有任何作用。除以上两种情况外（包括再次free已经被free过的非空指针），free的行为是未定义的，比较有可能的是free这个指针进程在某个时刻突然莫名其妙地崩溃。
3.calloc函数 C语言还提供了一个函数叫 calloc ， calloc 函数也用来动态内存分配。原型如下：

void*calloc( size_t num ,size_t size );

函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。
与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。举个例子：

#include #include #include #include int main() { int* p = calloc(10, sizeof(int)); //errno是存储错误信息 //用strerror函数返回错误码所对应的错误信息 if (p == NULL) { printf("%s\n", strerror(errno)); return -1; } //开辟成功了 int i = 0; for (i = 0; i < 10; i++) { printf("%d ", *(p + i)); } //释放空间 free(p); p = NULL; return 0; }

可能对于malloc与calloc有些疑问？什么情况下会开辟失败？？当然，内存空间不是无限大的，如果你开辟的过多，就会开辟失败，如：

malloc与calloc的异同：同：都可以动态分配内存空间
异：
malloc函数仅仅是申请内存空间，并且返回起始地址，并不去初始化；而calloc函数既申请内存空间，并且返回起始地址，又去初始化每个字节为0。
总结：
在应用中，想要初始化就应用calloc，不想初始化就用malloc即可。
4.realloc函数（为了更合理的时候内存）（追加增容）
realloc函数的出现让动态内存管理更加灵活。
有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。函数原型如下：

void*realloc (void* ptr, size_t size);

ptr 是要调整的内存地址。
size 是调整之后新大小空间。
返回值为调整之后的内存起始位置。（起初整个内存的开头）
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。
realloc在调整内存空间的是存在两种情况：

情况1：原有空间之后有足够大的空间
情况2：原有空间之后没有足够大的空间

情况1 当是情况1 的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。
情况2 当是情况2 的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。
由于上述的两种情况，realloc函数的使用就要注意一些。

原有空间之后有足够大的空间

文章图片

原有空间之后没有足够大的空间

文章图片

#include #include #include #include int main() { //calloc，申请空间，并初始化为0 int* p = calloc(10, sizeof(int)); //errno是存储错误信息 //用strerror函数返回错误码所对应的错误信息 if (p == NULL) { printf("%s\n", strerror(errno)); return -1; } //开辟成功了 int i = 0; for (i = 0; i < 10; i++) { *(p + i) = i; } //空间不够，增加空间至 20个int int* ptr = (int*)realloc(p, 20 * sizeof(int)); if (ptr != NULL) { p = ptr; } //以防空指针，造成越界访问，程序崩溃 else { return -1; } //给新开辟的空间赋值 for (i = 10; i < 20; i++) { *(p + i) = i; } //打印 for (i = 0; i < 20; i++) { printf("%d ", *(p + i)); } //释放空间 free(p); p = NULL; return 0; }

三、常见动态内存错误 1.对NULL指针的解引用操作错误写法：

int* p = (int*)malloc(20); *p = 20; //直接这样写，是有风险的！！ free(p);

改写：

int* p = (int*)malloc(20); if (p == NULL) { return -1; } *p = 20; //直接这样写，是有风险的！！ free(p);

2.对动态开辟空间的越界访问错误写法：

int main() { int* p = (int*)malloc(200); if (p == NULL) { return -1; } int i = 0; for (i = 0; i <= 80; i++) { *(p + i) = i; //当i是10的时候越界访问 } free(p); p = NULL; return 0; }

改写：

int main() { //此处的200，不是200个空间，而是200个字节，对应到int类型只是50个空间 //而访问的是0 ~ 80，造成了越界访问 int* p = (int*)malloc(200); if (p == NULL) { return -1; } int i = 0; for (i = 0; i <= 50/*80*/; i++) { *(p + i) = i; //当i是10的时候越界访问 } free(p); p = NULL; return 0; }

3.对非动态开辟内存使用free释放错误代码：

int main() { int a = 10; int* p = &a; free(p); p = NULL; return 0; }

该错误在于，变量a在内存的栈区，而free是释放动态内存的，即：对堆区的空间才有用，此时程序会崩溃。
4.使用free释放一块动态开辟内存的一部分错误代码：

int main() { int* p = (int*)malloc(10 * sizeof(int)); if (p == NULL) { return -1; } //使用 int i = 0; for (i = 0; i < 10; i++) { *p++ = i; } free(p); p = NULL; return 0; }

错误原因：
p最后指向的不再是起始地址，而free释放就要释放全部（free的脾气）。
5.对同一块动态内存多次释放错误代码：

int main() { int* p = (int*)malloc(10 * sizeof(int)); if (p == NULL) { return -1; } //使用 //... //释放 free(p); free(p); p = NULL; return 0; }

对于不属于自己的指针（已经释放过了，p不再维护该动态分配的空间了），再次进行free(p)，程序就会崩溃；请思考，这样写对不对呢？

//释放 free(p); p = NULL; free(p); p = NULL;

这样写，是对的，因为p已经置NULL了，而对于NULL，我们知道，free(BULL)；是没错的，只不过是没有用处的写法罢了！
6.动态开辟内存忘记释放（内存泄漏）错误代码：

//动态开辟的内存忘记释放 //在堆区申请的空间，有2种方式可以回收 //1.主动free //2.程序结束时，操作系统会自动回收int main() { int* p = (int*)malloc(10 * sizeof(int)); if (p == NULL) { return -1; } //使用 //... //忘记释放了 return 0; }

错误原因：
我们在堆区开辟的内存，一直未释放，就会一直存在与堆区，造成内存被占用，对应到后端程序就是，运行变卡；这样一块内存，我们不能够对他进行使用，也没有去释放掉，就造成了 “内存泄漏”。