即使行动导致错误，却也带来了学习与成长;不行动则是停滞与萎缩。💓💓💓
•🌙知识回顾
亲爱的友友们大家好！💖💖💖，我们紧接着要进入一个新的内容，就是动态内存的管理与分配，**上两篇文章我们详细解析了C语言中的自定义类型，包括结构、联合和枚举，**希望大家能够掌握并应用~
今天这篇文章给大家带来的是C语言中动态内存分配的知识，这是后面我们学习数据结构经常用到的，必须熟练掌握，希望大家好好学习，为后续数据结构打下基础，也希望可以给大家带来帮助。
👇👇👇
💘💘💘知识连线时刻（直接点击即可）
🎉🎉🎉复习回顾🎉🎉🎉
博主主页传送门：愿天垂怜的博客
🍋知识点一：为什么要有动态内存分配
我们学习了这么久的C语言，也掌握了开辟空间的方式有：
cpp
int a = 10;//在栈空间开辟了4个字节
char arr[10] = { 0 };//在栈空间开辟了10个字节的连续空间但是上面的两种开辟空间的方式有两个特点：
🔥空间开辟大小是固定的。
🔥数组在声明的时候，必须指定数组的长度，数组空间一旦确定了大小不能调整。
比如我需要描述一个班级学生的数学成绩，我创建了一个有30的元素的数组 int math[30] ，看似没什么问题，但是数组空间已经不能更改了，如果班级人数为35人，那这个数组就不够了，如果班级是20个人，空间又多余了，容易造成浪费。
所以对于空间的需求，不仅仅是固定不变的。有时候我们需要的空间大小在程序运行的时候才能知道，那数组编译时开辟空间的方式就不能满足了。
由此，C语言引入了动态内存的开辟，让程序员可以自己申请和释放内存，就比较灵活了。
而动态内存开辟包括三个部分：申请、使用、释放。
🍋知识点二：malloc和free
• 🌰1.malloc
C语言提供了一个动态内存开辟的函数：
cpp
void* malloc (size_t size);这个函数向内存申请了一块连续可用的空间，并返回指向这块空间的指针。
🔥如果开辟成功，则返回一个指向开辟好的空间的指针。
🔥如果开辟失败，则返回一个 NULL 指针，因此malloc的返回值一定要做检查。
🔥返回值类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候由使用者自己来决定。
🔥如果参数 size 单位是字节，如果size为0，malloc的行为是标准未定义的，取决于编译器。
举例：
cpp
#include <stdio.h>
#include <stdlib.h>
int main()
{
int* p = (int*)malloc(20);//开辟20个字节的空间
return 0;
}注意：指针变量p的类型是 int* 型，所以malloc开辟后的空间需要进行强制类型转换。
那malloc开辟空间在内存的什么地方呢？
可以看到，内存分为这几个区域：栈区、堆区、静态区、常量区和代码区，不同区域所存储的数据不同，由malloc申请的内存在内存的堆区。
💯代码演示：
cpp
#include <stdio.h>
#include <stdlib.h>
int main()
{
int* p = (int*)malloc(20);//开辟20个字节的空间
if (p == NULL)//判断申请是否成功
{
perror("malloc");
return 1;
}
for (int i = 0; i < 5; i++)
{
*(p + i) = i + 1;
}
for (int i = 0; i < 5; i++)
{
printf("%d ", *(p + i));//1 2 3 4 5
}
return 0;
}注意malloc是在头文件 <stdlib.h> 中声明的。
• 🌰2.free
C语言提供了另外一个函数free，专门用来做动态内存的释放和回收的，函数原型如下：
cpp
void free (void* ptr);我们再内存中用malloc开辟了动态内存，当我们使用完毕后应该会还给操作系统，正所谓有借有还，再借不难~
free函数用来释放动态开辟的内存。
🔥如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
🔥如果参数 ptr 是 NULL 指针，则函数什么事情都不做。
malloc和free的声明都在 <stdlib.h> 头文件中。
💯代码演示：
cpp
#include <stdio.h>
#include <stdlib.h>
int main()
{
int n = 0;
scanf("%d", &n);
int* p = (int*)malloc(n * sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;
}
for (int i = 0; i < n; i++)
{
*(p + i) = 0;
}
free(p);//释放
p = NULL;//释放后p是野指针，需要置为NULL
return 0;
}🍋知识点二：calloc和realloc
• 🌰1.calloc
C语言还提供了一个函数叫做calloc，calloc函数也是用来动态内存分配，函数原型如下：
cpp
void* calloc(size_t num, size_t size);🔥函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。
🔥与函数malloc的区别只在于calloc会在返回地址之前把之前申请的空间的每个字节都初始化为0。
举例：
cpp
#include <stdio.h>
#include <stdlib.h>
int main()
{
int* p1 = (int*)malloc(5 * sizeof(int));
int* p2 = (int*)calloc(5, sizeof(int));
return 0;
}上述p1、p2利用malloc和calloc所开辟的空间大小是一样的，但p2返回时会在返回地址之前把之前申请的空间的每个字节都初始化为0，也就是calloc比malloc多了一步初始化。
在使用上大同小异。
💯代码演示：
cpp
#include <stdio.h>
#include <stdlib.h>
int main()
{
int* p2 = (int*)calloc(5, sizeof(int));
if (p2 == NULL)
{
perror("calloc");
return 1;
}
//使用
//...
free(p2);
p2 = NULL;
return 0;
}• 🌰1.realloc
有时我们会发现过去申请的空间太小了，或有时候又会觉得我们申请的空间过大了，那为了合理的使用内存，我们需要对内存的大小做出灵活的调整，就有了realloc函数，原型如下：
cpp
void* realloc (void* ptr, size_t size);🔥 ptr 是要调整的内存地址， size 是调整时候的新大小，返回值为调整之后内存的起始位置。
🔥这个函数在调整原内存空间的基础上，还可能会将原来内存中的数据移动到新空间。
💯代码演示：
cpp
#include<stdio.h>
int main()
{
int* p = (int*)malloc(5 * sizeof(int));//20
//1 2 3 4 5
if (p == NULL)
{
perror("malloc");
return 1;
}
//使用
for (int i = 0; i < 5; i++)
{
*(p + i) = i + 1;
}
//希望将空间调整为40个字节
realloc(p, 40);
return 0;
}上面realloc函数在调整内存空间的时候是存在两种情况的：
🎉🎉🎉情况1：原有空间之后有足够大的空间🎉🎉🎉
这种情况扩容为40个字节，后面尚未分配的空间足够20个字节的大小，那直接从后面的空间中使用20个字节，然后返回起始地址 ptr 就可以了。
🎉🎉🎉情况2：原有空间之后没有足够大的空间🎉🎉🎉
但如果是这种情况，后面尚未分配的空间没有20个字节，会在堆区上寻找一块新的空间，并且大小为40个字节，同时将原有的数据拷贝一份到新的空间，同时释放旧的空间，此时返回的是新空间的地址 new 而非 ptr。
由于上述的两种情况，在使用realloc函数的时候就需要更加注意。
💯代码演示：
cpp
#include<stdio.h>
int main()
{
int* p = (int*)malloc(5 * sizeof(int));//20
if (p == NULL)
{
perror("malloc");
return 1;
}
//使用
for (int i = 0; i < 5; i++)
{
*(p + i) = i + 1;
}
//希望将空间调整为40个字节
int* ptr = (int*)realloc(p, 40);
if (ptr != NULL)//调整成功
{
p = ptr;
//对p进行后续操作
for (int i = 5; i < 10; i++)
{
*(p + i) = i + 1;
}
for (int i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
}
else//调整失败
{
perror("realloc");
free(p);
p = NULL;
}
return 0;
}如果大家能够读懂上面的代码，相信对动态内存分配的四个函数都已经理解深刻了。
🍋知识点三：常见的动态内存的错误
• 🌰1.对NULL指针的解引用操作
cpp
void test()
{
int* p = (int*)malloc(INT_MAX);
*p = 20;//如果p的值是NULL，就会有问题
free(p);
}对于任何动态内存的开辟（malloc、calloc），都有可能开辟失败，如果开辟失败将会返回空指针，如果我们不加以检查，就会造成对空指针的解引用，实际上malloc是不能开辟 INT_MAX 这么大的一个空间的，所以我们一定要进行检查，正确格式如下：
cpp
void test()
{
int* p = (int*)malloc(INT_MAX);
if (p == NULL)
{
perror("malloc");
return 1;
}
else
{
*p = 20;//此时p不为空指针
free(p);
}
}• 🌰2.对动态开辟空间的越界访问
cpp
void test()
{
int i = 0;
int* p = (int*)malloc(10 * sizeof(int));
if (NULL == p)
{
exit(EXIT_FAILURE);//退出程序
}
for (i = 0; i <= 10; i++)
{
*(p + i) = i;//当i是10的时候越界访问
}
free(p);
}上面我们开辟了一个40个字节大小的空间，能够放入10个 int 型的整数，但是在for循环中我们给空间赋值了11位整数，这样会造成动态开辟空间的越界访问，程序将会崩溃。
注意：程序执行到exit语句将会直接退出程序，执行到return语句将会直接退出当前函数。
• 🌰3.对非动态开辟内存的free释放
cpp
void test()
{
int a = 10;
int* p = &a;
free(p);//ok?
}大家可以返回去看看free函数的介绍，其中说明了如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。上面p指向的并不是动态开辟的空间，不应该使用free也不需要使用free（程序会崩溃），因为对于局部变量而言，具有自动存储期的变量在进入作用域时创建，出作用域时销毁。
• 🌰4.使用free释放一块动态开辟内存的一部分
cpp
void test()
{
int* p = (int*)malloc(100);
p++;
free(p);//p不再指向动态内存的起始位置
}p++之后，不再指向动态内存的起始位置，而是跳过了一个 int 后的位置
在使用free释放空间的时候，一定要把空间的起始位置传递给free，不能随便传入一个地址，或从半途中来释放其中的一部分，这是不行的，否则程序会崩溃。
• 🌰5.对同一块动态内存多次释放
cpp
void test()
{
int* p = (int*)malloc(100);
free(p);
free(p);//重复释放
}p申请了100字节大小的空间，但是却对这块空间释放了两次，这是不行的，程序也会崩溃 。但如果在第一次释放后将p置为 NULL ，那就不会又问题了，因为如果free函数的参数是 NULL 指针，则函数什么事情都不做。
• 🌰6.动态开辟内存忘记释放（内存泄露）
cpp
void test()
{
int* p = (int*)malloc(100);
if (NULL != p)
{
*p = 20;
}
}
int main()
{
test();
while (1);
}p申请了100个字节大小的空间，但是却忘记了将其释放，这会造成内存泄露，在 test 函数中没有释放，那出了这个函数就连释放的机会也没有了，也就是这块内存再也找不见了，没有还给操作系统。
所以我们再平常写代码的时候尽量要做到谁申请的资源谁去释放，或者给别人去用。如果不去释放，程序结束后，也会由操作系统来自动回收。
🍋知识点四：动态内存经典笔试题分析
• 🌰1.题目1
cpp
#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;
}请问运行 Test 函数会由什么样的结果？
有些人认为：创建字符指针并置为 NULL ，传参给 GetMemory函数，将p修改为指向动态开辟100个字节大小空间的指针，并将字符串"hello wolrd"拷贝给str。
但真的是这样吗？
其实由这张图我们就能很清楚地发现，我们传过去的是指针变量，而且是想修改这个指针变量自身的值，接收指针变量的p只是str的一份临时拷贝，对形参的修改并不会影响到实参，所以str还是 NULL ，而p出了函数后就会被销毁。形成了对 NULL 指针的访问，即非法访问。想要修改传过去的参数，就应该传它的地址，即传址调用。
上面代码的两个问题：
🔥p是形参变量，出了函数变被销毁，而p指向的是动态申请的内存，这样就会造成内存泄露。
🔥str指针变量中依然是 NULL 指针，如果要拷贝，就会发生内存的非法访问，可能导致程序崩溃。
💯正确代码：
cpp
#include <stdio.h>
#include <stdlib.h>
void GetMemory(char** p)//二级指针接收
{
*p = (char*)malloc(100);
}
void Test(void)
{
char* str = NULL;
GetMemory(&str);//想要修改str，就要传str的指针
strcpy(str, "hello world");
printf(str);
free(str);
str==NULL;
}
int main()
{
Test();
return 0;
}• 🌰2.题目2
返回栈空间地址的问题
cpp
#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;
}请问运行 Test 函数会由什么样的结果？
题目大体的意思是想将字符指针str指向字符数组"hello world"然后打印出这个数组，但上面代码是实现不了预期功能的。
由与数组p在函数内部，**属于局部变量，所以它的作用域范围只有它创建到函数结束这一段，**而出了这个函数p就会被销毁，p就会被还给操作系统，而这块空间有没有被别人改掉，里面到底存放了什么就不从而知了，所以str并不能正确的指向字符数组，而结果将会是乱码。
我们再看看另外一个同样是存在返回栈空间地址问题的代码：
cpp
#include <stdio.h>
#include <stdlib.h>
void Test(void)
{
int n = 100;
return &n;
}
int main()
{
Test();
return 0;
}这个代码也是相同的问题，可以自己分析以下。
• 🌰3.题目3
cpp
#include <stdio.h>
#include <stdlib.h>
void GetMemory(char** p, int num)
{
*p = (char*)malloc(num);
}
void Test(void)
{
char* str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
}
int main()
{
int* p = Test();
return 0;
}请问运行 Test 函数会由什么样的结果？
这段代码和我们之前题目1优化的版本其实是相似的，唯一还有个问题就是堆上申请的空间没有主动释放，所以会造成内存泄露。
正确代码和题目1类似，大家可以参照自己改改，其实就多了一步释放，也是非常简单的。
• 🌰4.题目4
cpp
#include <stdio.h>
#include <stdlib.h>
void Test(void)
{
char* str = (char*)malloc(100);
strcpy(str, "hello");
free(str);
if (str != NULL)
{
strcpy(str, "world");
printf(str);
}
}
int main()
{
Test();
return 0;
}这段代码在拷贝后释放了str，但是大家请注意，free是释放str指向的空间，本质上是放弃了str指向的空间的使用权限，但是str中依然保存着前面malloc申请的100个字节的起始地址。也就是说，还是会执行if语句中的内容，会将world拷贝到str的空间上，但是str指向的空间已经不属于当前程序的空间了，若坚持拷贝，就形成了非法访问内存，程序可能崩溃。
因此，为了避免出现野指针的相关问题，free（str）后应该将其置为 NULL 。
🍋知识点四：柔性数组
也许你从来没有听说过**柔性数组（flexible array）**这个概念，但是它确实是存在的。
C99中，结构中的最后一个元素允许是未知大小的数组，这就叫做【柔性数组】成员。
我们从定义中提取出关键信息：
🔥结构体中，最后一个成员。
🔥最后一个成员是数组，数组没有指定大小。
这样的数组才叫做柔性数组。
例如：
cpp
struct S
{
char c;
int i;
int arr[];//柔性数组
//或int arr[0]
};• 🌰1.柔性数组的特点
🔥结构体中的柔性数组成员前面必须有至少一个其他成员。
🔥sizeof 返回的这种结构体大小不包括柔性数组的内存。
🔥包含柔性数组成员的结构体用malloc()函数进行内存的动态分配，并且分配的内存应该大于结构体的大小，以适应柔性数组的预期大小。
💯代码1：
cpp
#include <stdio.h>
struct S
{
int i;
int arr[];
};
int main()
{
printf("%zd\n", sizeof(struct S));//结果为4
return 0;
} • 🌰2.柔性数组的使用
cpp
#include <stdio.h>
#include <stdlib.h>
struct S
{
int n;
int arr[];
};
int main()
{
struct S* ps = (struct S*)malloc(sizeof(struct S) + 5 * sizeof(int));
if (ps == NULL)
{
perror("malloc");
return 1;
}
ps->n = 100;
for (int i = 0; i < 5; i++)
{
ps->arr[i] = 1;
}
//调整空间
struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 10 * sizeof(int));
if (ptr != NULL)
{
ps = ptr;
}
//使用...
//释放
free(ps);
ps = NULL;
return 0;
}这段代码看着很长，其实很多都是咱再上面讲过的一些格式，柔性数组柔性再什么地方，我们看图说话：
也就是说，我们可以用realloc来调整柔性数组的大小，而n的大小是sizeof（struct S）不变的，变化的是k*sizeof（int）中的k。
我们也可以用指针的方式实现数组的柔性变化：
cpp
#include <stdio.h>
#include <stdlib.h>
struct S
{
int n;
int *arr;
};
int main()
{
struct S* ps = (struct S*)malloc(sizeof(struct S) + 5 * sizeof(int));
if (ps == NULL)
{
perror("ps: malloc");
return 1;
}
ps->arr = (int*)malloc(5 * sizeof(int));
if (ps->arr == NULL)
{
perror("ps->arr: malloc");
return 1;
}
//使用
ps->n = 100;
for (int i = 0; i < 5; i++)
{
ps->arr[i] = i;
}
//调整数组大小
int* ptr = (int*)realloc(ps->arr, 10 * sizeof(int));
if (ptr != NULL)
{
ps->arr = ptr;
}
//使用...
//释放
free(ps->arr);
ps->arr = NULL;
free(ps);
ps = NULL;
return 0;
}也就是说，arr如果是个指针，那么它指向的内容也是可以动态开辟的，就可以在不使用柔性数组的情况下实现数组的柔性变化。
两种方式都是可以的。
• 🌰2.柔性数组的优势
上面两种方案，柔性数组的方式有什么优势呢？
🔥方便内存释放
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并且把整个结构体返回给用户，用户调用free可以释放结构体，但是用户可能并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并且返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
🔥有利于访问速度
连续的内存有益于提高访问速度，也有益于减少内存碎片（其实也没多高了，反正都跑不了要用作偏移量的加法来寻址）。
扩展阅读： 🎉🎉🎉C语言结构体里的成员数组和指针🎉🎉🎉
•🌙SumUp 结语
C语言动态内存管理的学习到这里就结束啦~后面就会进入文件操作的学习。在这里希望大家能够将前面的C语言的的基础知识进行回顾复习，使整个纯C学习是连贯的，这样更加利于我们的学习和理解以及继续拓展。
如果大家觉得有帮助，麻烦大家点点赞，如果有错误的地方也欢迎大家指出~
