C语言进阶想用好C++？那就一定要掌握动态内存管理
Posted 銮崽的干货分享基地
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C语言进阶想用好C++？那就一定要掌握动态内存管理相关的知识，希望对你有一定的参考价值。
目录
🛰️博客主页：✈️銮同学的干货分享基地
🛰️欢迎关注：👍点赞🙌收藏✍️留言
🛰️系列专栏：💐【进阶】C语言学习
🛰️代码仓库：🎉VS2022_C语言仓库
家人们更新不易，你们的👍点赞👍和👉关注👈真的对我真重要，各位路过的友友麻烦多多点赞关注，欢迎你们的私信提问，感谢你们的转发！
关注我，关注我，关注我，你们将会看到更多的优质内容！！
🏡🏡 本文重点 🏡🏡：
🚅动态内存🚃动态内存函数🚃常见动态内存错误🚏🚏
🤩前言🤩：
C 语言是一门神奇、实用而又基础的语言，我们几乎可以说所有的编程语言，都是在 C 语言的基础上发展而来的。许多小伙伴们学习 C 语言的目的，都是为了继续学习其它的高级语言，而我们学习各种语言的最终目的，一定是为了写出更好的代码和程序，寻找一份满意的工作。
而今天这篇博客的内容，就是关于如何通过开辟动态内存，从而写出更加优秀的程序的。同时今天的内容对于以后想要继续学习 C++ 的同学们来说尤为重要，希望各位小伙伴们能够认真学习仔细思考，多多练习牢固掌握。
一、动态内存概述⚔️：
接下来我们就正式开始关于动态内存的学习，首先我们先来大致了解一下动态内存。
1.什么是动态内存：
在c/c++语言中，所谓动态内存分配，就是指在程序执行的过程中动态地分配或者回收存储空间的分配内存的方法。动态内存分配不像数组等静态内存分配方法那样需要预先分配存储空间，而是由系统根据程序的需要即时分配，且分配的大小就是程序要求的大小。
2.动态内存分配的意义：
我们在之前的学习过程中，在使用各种变量与数组等等功能时，都需要从内存中开辟出一片空间用于存放我们的数据，而在之前我们掌握的内存开辟方式有：
int value = 20;
//在内存栈空间上开辟4个字节的空间
char arr[10] = 0 ;
//在栈空间上开辟10个字节的连续空间但是我们最经常时使用的这两种内存空间的开辟方式有一些共同的特点：
1. 空间开辟大小是固定的。
2. 数组在申明的时候必须指定数组的长度，它所需要的内存将会在编译时分配。
换句话说，这两种内存开辟方式都是静态内存分配。
但是我们在日常的代码编写和程序使用过程中，对于空间的需求往往不仅限于上述情况。更多的时候我们需要的空间大小只有在在程序运行的时候才能知道。如此，数组等在编译时开辟空间的方式无法满足我们的实际运行需求。
例如：
1. 通讯录创建联系人数据 data[1000]，实际有联系人13个，造成大量的空间浪费。
2. 通讯录创建联系人数据 data[20]，后期共有联系人113人，初期开辟的空间不够用。
于是就需要使用一种更好的内存分配方式进行处理，动态内存分配应运而生。
二、常用的动态内存函数🏹：
1. malloc 和 free：
malloc 函数（memory allocate，即内存分配）的作用为向内存的堆区申请空间用于存储数据，free 函数的作用为释放使用 malloc 函数向堆区申请的空间，并将空间归还给内存的堆区空间，通过配合使用这两个函数可以从堆区申请（释放）动态内存空间。
①. malloc 函数：
我们首先来看 malloc 函数：
我们可以看到，malloc 函数的使用格式为：
void* malloc (size_t size);
从它的使用格式中我们可以看出，该函数向堆区申请了一块连续的空间，同时返回的是这块空间的指针。
★ 如果开辟成功，则返回一个指向开辟好空间的指针。
★ 如果开辟失败，则返回一个 NULL 指针，故我们在使用时一定要仔细检查 malloc 函数的返回值。
★ 返回值的类型是 void* ，即 malloc 函数并不了解开辟空间的类型，至于空间的具体类型将在使用时由使用者自己决定。
★ 如果参数 size 为 0，则 malloc 函数的行为是标准未定义的，将会取决于编译器。
②. free 函数：
我们同样先来看看我们的 free 函数：
我们可以看到，free 函数的使用格式为：
void free (void* ptr);
不同的是，与 malloc 函数恰好相反，free函数的作用为释放动态开辟的内存，同时没有返回值：
★ 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
★ 如果参数 ptr 是NULL指针，则 free 函数将什么都不会做。
③. malloc 函数与 free 函数的使用：
关于两个函数的实际使用，我们直接来看下面这段 malloc 函数与 free 函数的使用实例：
#include<stdio.h>
#include<stdlib.h>
int main()
int* ptr = NULL;
//初始化指针
ptr = (int*)malloc(40);
//使用malloc函数动态申请40字节空间
//同时因为指针ptr类型为int*，而 malloc 函数的返回类型为void*，故使用强制类型转换
int* p = ptr;
//在此定义指针p的原因是，在之后的使用中，指针p的指向会发生改变
//若不对初始指针指向进行保存，将无法释放改变前与改变后之间的空间
if (p == NULL)
//mallocc函数在动态空间开辟失败时返回空指针
//即若此处为空指针，说明动态内存空间申请失败
perror("malloc");
//打印malloc函数动态空间申请错误原因，并结束程序
return 1;
//没有结束说明指针不为空，动态空间申请成功
int i = 0;
for (i = 0; i < 10; i++)
*p = i;
//循环向动态内存空间中存入数据
p++;
//在此处的操作中，指针p的指向发生了改变
//使用完成后释放动态内存空间：
free(ptr);
//指针p指向发生改变，但指针ptr仍指向初始指针
ptr = NULL;
//动态内存空间归还后，重新将指针ptr置空
//动态内存空间已经归还，若不将指针ptr进行置空，指针ptr将变为野指针，指向将不可控，这在程序运行中非常危险
return 0;
具体的使用方法在注释中已经注明了，在这里我们要在对其中几个地方再次进行强调：
1. 在对指针进行操作前一定要保存指向初始位置的原始指针。
2. 在对指向动态内存空间的指针进行使用前，一定要进行非空判断。
3. 在动态内存空间使用完毕并释放后，一定要将指针进行置空操作。
4. 当程序结束时若动态内存空间没有被释放，将会被操作系统自动回收。
5. 但若程序不结束且申请的动态内存空间持续不归还，动态内存将不会被回收，就会导致内存泄漏问题。
2. calloc 函数：
我们来看这个函数：
可以看到，calloc 函数的使用格式为：
void* calloc (size_t num, size_t size);
更通俗的说，calloc 函数的功能就是，为 num 个大小为 size 的元素开辟一块动态内存空间，并将空间内每个字节都初始化为 0。
其使用方式与 malloc 函数无异：
#include<stdio.h>
#include<stdlib.h>
int main()
int* ptr = NULL;
ptr = (int*)calloc(10, sizeof(int));
//使用calloc函数动态申请10个int类型大小的空间
//同时因为指针ptr类型为int*，而calloc函数的返回类型为void*，故使用强制类型转换
int* p = ptr;
if (p == NULL)
perror("calloc");
return 1;
int i = 0;
for (i = 0; i < 10; i++)
*p = i;
p++;
free(ptr);
ptr = NULL;
return 0;
并且实际作用相比较来说，与函数 malloc 的区别仅在于 calloc 函数在返回地址前会把申请的空间内每个字节都初始化为 0 ，其它方面完全相同。
也就是说，如果我们需要将申请来的动态内存空间进行初始化，那么我们就可以通过使用 calloc 函数来达到我们的目的。
3. realloc 函数：
我们来看 realloc 函数：
realloc 函数（re - allocate，即重新分配）的作用为重新分配从堆区申请来的动态内存空间的大小。其使用格式为：
void* realloc (void* ptr， size_t size);
前面 malloc 、free 与 calloc 三个函数的存在，都是为了向堆区申请或释放动态内存空间，但是倘若只使用前三个函数，我们可以发现，申请来的内存空间的看起来与静态内存空间似乎没有什么太大的区别。
于是，recalloc 函数出现了。
realloc 函数的出现，使得动态内存管理更加的灵活。例如有些时侯我们觉得前面申请的空间太小了不够用，或者我们会觉得申请的空间过大了太浪费，这个时候我们就可以通过使用 realloc 函数对之前开辟的动态内存空间的大小再次进行合理的调整。
换句话说，正是 realloc 函数才使得动态内存空间真正变得“ 动态 ”起来。
例如我们可以直接修改上面的例子，当我们在使用过程中发现我们申请来的动态内存空间不够用时，我们就可以通过使用 realloc 函数来对我们申请来的动态内存空间进行扩容：
#include<stdio.h>
#include<stdlib.h>
int main()
int* ptr = NULL;
ptr = (int*)malloc(40);
int* p = ptr;
if (p == NULL)
perror("malloc");
return 1;
int i = 0;
for (i = 0; i < 10; i++)
*p = i;
p++;
realloc(ptr, 80);
//空间不够用，重新分配更大的空间
//将指针ptr指向的空间扩容至80字节
free(ptr);
PTR = NULL;
return 0;
但哪怕是在成功扩容时，也仍会出现两种情况：当前空间与后相邻空间之间的空间是否足够 realloc 函数进行扩容操作。
★ 若空间足够，则直接执行扩容操作，并在扩容完成后返回指向起始位置的指针。
★ 若空间不够，则将会在堆区中重新寻找合适的空间（足以容纳下扩容后的全部空间），并将原空间内的数据全部拷贝过来，接着释放原空间，并在扩容完成后返回指向新空间起始位置的指针。
但是还有最特殊的情况，即内存堆空间中没有能够容纳整个扩容后的动态内存空间的空间时，将会返回空指针。所以，我们在想要使用扩容后的动态内存空间时，为了避免使用指针内容为空指针而造成的意外错误，在使用之前首先应当对 realloc 函数返回的指针进行非空判断，之后再拿来使用：
#include<stdio.h>
#include<stdlib.h>
int main()
int* ptr = NULL;
ptr = (int*)malloc(40);
int* PTR = NULL;
PTR = (int*)realloc(ptr, 80);
int* p = NULL;
//空间不够用，重新分配更大的空间
//将指针ptr指向的空间扩容至80字节
if (PTR != NULL)
//使用前进行非空判断，避免出现无法预料的错误
p = PTR;
//判断非空，即扩容成功，开始使用：
int i = 0;
for (i = 0; i < 20; i++)
*p = i;
p++;
free(PTR);
PTR = NULL;
return 0;
三、常见动态内存错误🛡️：
1.对 NULL 指针的解引用操作：
int main()
int* p = (int*)malloc(INT_MAX);
//当尝试开辟的空间过大时，将会导致动态内存开辟失败
//此时malloc函数将会返回空指针，即此时指针p也是空指针
*p = 20;
//没有判断非空就对指针p进行解引用操作，导致产生对空指针进行了解引用操作
//将会造成内存非法访问的错误
free(p);
p = NULL;
return 0;
避免出现此类问题的方法是，在指针使用前对 malloc 等函数的返回值进行非空判断。
2.对动态内存空间的越界访问;
int main()
int* p = (int*)malloc(10 * sizeof(int));
if (NULL == p)
perror("malloc");
return 1;
int i = 0;
for (i = 0; i <= 10; i++)
*(p + i) = i;
//当i=0时，将会出现越界访问的错误
free(p);
p = NULL;
return 0;
避免此类错误的方式是，在使用时仔细认真的进行内存边界的检查，并选择合适的空间访问范围。
3.对非动态内存空间使用 free 函数：
int main()
int a = 10;
//变量a所使用的内存空间不是动态内存空间
int* p = &a;
free(p);
//释放非动态内存空间
p = NULL;
return 0;
避免此类错误的方式是，在进行空间释放时注意区分静态内存空间与动态内存空间。
4.使用 free 函数释放动态内存空间的一部分：
int main()
int* p = (int*)malloc(10 * sizeof(int));
if (p == NULL)
perror("malloc");
return 1;
int i = 0;
for (i = 0; i < 10; i++)
*p = i;
p++;
//此时指针p的指向已经发生变化，不再指向起始位置
free(p);
//释放部分动态内存空间
p = NULL;
return 0;
避免此类错误的方法是，在使用指针前保存好初始指向，并在进行动态内存释放时释放完整的动态内存空间。
5.对同一块动态内存空间多次释放：
int main()
int* p = (int*)malloc(10 * sizeof(int));
free(p);
//...(在中间又进行了很多其它操作之后，忘记了已经释放过动态内存空间，并进行了重复释放)
free(p);
//重复释放动态内存空间
p = NULL;
return 0;
避免此类问题的方法是，在已经释放过动态内存空间之后，一定要加以注释以提醒自己避免重复释放同一块动态内存空间。
6.不释放动态内存空间（内存泄漏）：
void test()
int* p = (int*)malloc(10 * sizeof(int));
if (p != NULL)
*p = 20;
//判断非空后进行使用
//使用后没有释放动态内存空间，在程序终止前该动态内存空间都将无法被释放，将会逐渐蚕食计算机系统的内存
int main()
test();
while (1);
//为了演示内存泄漏，使程序永不终止
return 0;
避免此类问题的方法是，永远记住，使用一个释放一个，使用结束立刻释放。
🥳总结🥳：
到这里我们今天关于动态内存管理的介绍与学习就结束啦，通过今天内容的学习，相信各位小伙伴们已经掌握了动态内存的开辟、释放与动态修改，并且已经对动态内存空间的各项使用注意事项有了一定的认知和了解。希望小伙伴们在下去以后，在对动态内存空间的使用和管理中一定要慎之又慎，尽最大可能避免出现类似的相关问题。
🔥🔥只有承担起旅途风雨，才能最终守得住彩虹满天！！！🔥🔥
更新不易，辛苦各位小伙伴们动动小手，👍三连走一走💕💕 ~ ~ ~ 你们真的对我很重要！最后，本文仍有许多不足之处，欢迎各位认真读完文章的小伙伴们随时私信交流、批评指正！
《C语言深度剖析》第五章 内存管理 p1(完结)（ C语言从入门到入土（进阶篇）
目录
本章节文章是作者通过观看《C语言深度剖析》等各种资料总结的精华，基础部分省略了不少，是为了让大家能够更加深入了解C语言的魅力！因为为了避免与之前的文章发生赘述，所以就直接讲作者认为的精华部分哈！现在正文开始!
谁都不能阻挡你成为更优秀的人。
内存管理
1. 什么是动态内存
就是开辟在堆上的内存，而且要用特定的函数去开辟，我们常用的是malloc，和free（释放空间）
返回一个内存块给用户，返回成功就是那块空间的起始地址，失败就是NULL。
free释放空间，参数就是之前获取返回值的指针变量。
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <windows.h>
#define N 10
int main()
int *p = (int*)malloc(sizeof(int)*N); //动态开辟空间
if (NULL == p)
return 1;
for (int i = 0; i < N; i++)
p[i] = i;
for (int i = 0; i < N; i++)
printf("%d ", i);
printf("\\n");
free(p); //开辟完之后，要程序员自主释放
system("pause");
return 0;
2. 为什么要有动态内存
1. 在技术方面，普通的空间申请，都是在全局或者栈区，全局一般不太建议大量使用，而栈空间有限，那么如果一个应用需要大量的内存空间的时候，需要通过申请堆空间来支持基本业务。
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <windows.h>
#define N 10
int main()
char a[1024 * 1024]; //就简单的1M空间，程序就崩溃了
system("pause");
return 0;
2. 在应用方面，程序员很难一次预估好自己总共需要花费多大的空间。想想之前我们定义的所有数组，因为其语法约束，我们必须得明确"指出"空间大小.但是如果用动态内存申请（malloc），因为malloc是函数，而函数就可以传参，也就意味着，我们可以通过具体的情况，对需要的内存大小进行动态计算，进而在传参申请，提供了很大的灵活性
3. 栈、堆和静态区
我们发现地址从上到下依次增大，而且堆区（heap addr）和栈区差距巨大，也就是说中间有巨大的漏空（堆区向上增长，栈区向下增长）（也就是我们图中所看到的）。
问一个问题：在C语言中，为何一个临时变量，使用static修饰之后，它的生命周期变成全局的了？
编译的时候被编译进了全局数据区。（全局特性，但是注意作用域还是不变，只是生命周期是整个程序的生命周期）PS:栈区随着申请与释放而进行空间管理，而其他的区，基本上都是随着整个程序的运行而一直存在。
4.
4.1. 常见的内存错误
1.指针没有指向一块合法的内存2.为指针分配的内存太小3.内存分配成功，但并未初始化4.内存越界(越界是一个很严重的问题，但不是所有严重的问题都会表现出来 )5.内存泄漏
4.1. 注意
assert称为断言，如果内部条件不满足，就会报错，满足就什么都不做。但是一般用if,因为如果我们需要的情况是指针为NULL（默认行为）assert是解决不了的，而且assert一般只有在发布方式为 Debug下面有效，还有要是我们自己定义一个地址去指向非法行为，assert（if）也是没有办法去判断的，因为他也不知道用那个地址是不是非法的，所以我们写指针如果未直接引用，就要设置为NULL。
4.2. 可以用memset来初始化
4.3. 内存泄漏如果程序退出了，问题还在吗？
答案是当一个程序开辟了很多空间但是没有去释放，发生内存泄漏，但是如果程序结束，操作系统会强制把开辟的内存回收，也就是释放内存，所以是不在了。(注意不是编译器回收哈，因为代码运行起来之后就和编译器没有关系了)
那问题又来了，那什么程序最怕内存泄漏，就是那些不会主动退出的程序或者说很少主动退出的程序。（一般常见的有：操作系统，杀毒软件，服务器程序）（我们把这种经常性得使用的程序称为常驻（内存）进程（程序））
4.4. 内存开辟实际上比我们预要开辟得多，为什么？
我们可以发现，我们free的时候只知道起始地址，并没有说要释放多少字节
这是执行free语句的结果
但是我们free的时候发现变红的远不止20个，也就是说释放的远不止20个空间，也就意味着曾经申请的空间一定比20个字节多（这个多（kookie）是个固定的值，但是看编译器等）。多出来的部分其实是记录这次申请的更详细信息（申请空间多大，申请时间等）。再多说一句，所以申请大空间比较好，因为kookie的比值就小，而刚好申请小空间我们用栈，所以刚好互补。
4.5. 内存释放的本质上是什么？
我们发现释放前和释放后p的值没变。那此时还能访问堆空间吗？
答案是不能，为什么呢?
这里来一个例子，假设你心中有一个女朋友的变量空间，里面开始什么都没有，后来喜欢上了一个人，然后你们在一起了，她的名字就在我们的变量空间里面，但是后来因为某种原因，她不喜欢你了，分手了，这就相当于free，但是她的名字任然在我们之前的空间里面，但是我们不能再去找她玩了，因为我们现在没有关系了，这个free就相当于取消了我们之间的关系，再去找她，就相当于野指针访问了！
那free会不会将p置为空？
其实是不会的我们发现，为什么呢？因为此时用p再访问已经就是非法访问了，此时对系统没有影响，影响的只是我们自己的程序（分手后走不出来，和前女友没有关系，伤害的是我们自己啊QAQ），所以系统并没有强制设定为空，但是我们自己并不想这样，因为可能会出错（可能走不出来），所以我们free之后常把他设置为NULL（封心封心）。
5. C中动态内存“管理”体现在哪
在今天的学习中，我们有效学到的函数是malloc和free，能够进行有效的空间申请和释放了那么，通常书中所说的内存“管理”体现在哪里呢？难道就是malloc和free？内存管理的本质其实是：空间什么时候申请，申请多少，什么时候释放，释放多少的问题。1. 场景：C的内存管理工作是由程序员决定的，而程序员什么时候申请，申请多少，什么时候释放，释放多少都是有场景决定的(比如上面的链表操作)，而大部分书中，是讲具体操作，很少有场景，所以管理工作体现的并不直观。不过我们现在能理解即可。2. 其他高级语言：像java这样的高级语言，语言本身自带了内存管理，所以程序员只管使用即可。换句话说，内存管理工作，程序员是不用关心的。但是C是较为底层的语言，它的内存管理工作是暴露给程序员的，从而给程序员提供了更多的灵活性，不过，管理工作也同时交给了程序员。所以，因为上面的两点，C中内存章节，基本都叫做内存管理在C中，程序员+场景=内存管理
今天的内容就到这里了哈！！！
要是认为作者有一点帮助你的话！
就来一个点赞加关注吧！！！当然订阅是更是求之不得！
最后的最后谢谢大家的观看！！！
你们的支持是作者写作的最大动力！！！
下期见哈！！！
以上是关于C语言进阶想用好C++？那就一定要掌握动态内存管理的主要内容，如果未能解决你的问题，请参考以下文章