即使行动导致错误，却也带来了学习与成长;不行动则是停滞与萎缩。💓💓💓

目录

•🌙知识回顾

🍋知识点一：为什么要有动态内存分配

🍋知识点二：malloc和free

 • 🌰1.malloc

 • 🌰2.free

🍋知识点二：calloc和realloc 

  • 🌰1.calloc

• 🌰1.realloc

🍋知识点三：常见的动态内存的错误 

• 🌰1.对NULL指针的解引用操作

​编辑• 🌰2.对动态开辟空间的越界访问

​编辑• 🌰3.对非动态开辟内存的free释放

​编辑• 🌰4.使用free释放一块动态开辟内存的一部分

• 🌰5.对同一块动态内存多次释放

​编辑• 🌰6.动态开辟内存忘记释放（内存泄露）

🍋知识点四：动态内存经典笔试题分析

 • 🌰1.题目1

​编辑

 • 🌰2.题目2

 • 🌰3.题目3

 • 🌰4.题目4

🍋知识点四：柔性数组 

 • 🌰1.柔性数组的特点

​编辑 • 🌰2.柔性数组的使用

​编辑 • 🌰2.柔性数组的优势

•🌙SumUp 结语

•🌙知识回顾

亲爱的友友们大家好！💖💖💖，我们紧接着要进入一个新的内容，就是动态内存的管理与分配，上两篇文章我们详细解析了C语言中的自定义类型，包括结构、联合和枚举，希望大家能够掌握并应用~

    

今天这篇文章给大家带来的是C语言中动态内存分配的知识，这是后面我们学习数据结构经常用到的，必须熟练掌握，希望大家好好学习，为后续数据结构打下基础，也希望可以给大家带来帮助。

  

👇👇👇
💘💘💘知识连线时刻（直接点击即可）

  🎉🎉🎉复习回顾🎉🎉🎉

        自定义类型结构体详细讲解

        自定义类型联合和枚举讲解超详细

博主主页传送门：愿天垂怜的博客

🍋知识点一：为什么要有动态内存分配

我们学习了这么久的C语言，也掌握了开辟空间的方式有：

	int a = 10;//在栈空间开辟了4个字节char arr[10] = { 0 };//在栈空间开辟了10个字节的连续空间

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

🔥空间开辟大小是固定的。

🔥数组在声明的时候，必须指定数组的长度，数组空间一旦确定了大小不能调整。

比如我需要描述一个班级学生的数学成绩，我创建了一个有30的元素的数组 int math[30] ，看似没什么问题，但是数组空间已经不能更改了，如果班级人数为35人，那这个数组就不够了，如果班级是20个人，空间又多余了，容易造成浪费。

所以对于空间的需求，不仅仅是固定不变的。有时候我们需要的空间大小在程序运行的时候才能知道，那数组编译时开辟空间的方式就不能满足了。

由此，C语言引入了动态内存的开辟，让程序员可以自己申请和释放内存，就比较灵活了。

而动态内存开辟包括三个部分：申请、使用、释放。

🍋知识点二：malloc和free

 • 🌰1.malloc

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

void* malloc (size_t size);

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

🔥如果开辟成功，则返回一个指向开辟好的空间的指针。

🔥如果开辟失败，则返回一个 NULL 指针，因此malloc的返回值一定要做检查。

🔥返回值类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候由使用者自己来决定。

🔥如果参数 size 单位是字节，如果size为0，malloc的行为是标准未定义的，取决于编译器。

举例：

#include <stdio.h>
#include <stdlib.h>
int main()
{int* p = (int*)malloc(20);//开辟20个字节的空间return 0;
}

 注意：指针变量p的类型是 int* 型，所以malloc开辟后的空间需要进行强制类型转换。 

那malloc开辟空间在内存的什么地方呢？

可以看到，内存分为这几个区域：栈区、堆区、静态区、常量区和代码区，不同区域所存储的数据不同，由malloc申请的内存在内存的堆区。

💯代码演示：

#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，专门用来做动态内存的释放和回收的，函数原型如下：

void free (void* ptr);

我们再内存中用malloc开辟了动态内存，当我们使用完毕后应该会还给操作系统，正所谓有借有还，再借不难~

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

🔥如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。

🔥如果参数 ptr 是 NULL 指针，则函数什么事情都不做。

malloc和free的声明都在 <stdlib.h> 头文件中。

💯代码演示：

#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是野指针，需要置为NULLreturn 0;
}

🍋知识点二：calloc和realloc 

  • 🌰1.calloc

C语言还提供了一个函数叫做calloc，calloc函数也是用来动态内存分配，函数原型如下：

void* calloc(size_t num, size_t size);

🔥函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。

🔥与函数malloc的区别只在于calloc会在返回地址之前把之前申请的空间的每个字节都初始化为0。

举例：

#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多了一步初始化。

在使用上大同小异。

💯代码演示：

#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函数，原型如下：

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

 🔥 ptr 是要调整的内存地址， size 是调整时候的新大小，返回值为调整之后内存的起始位置。

🔥这个函数在调整原内存空间的基础上，还可能会将原来内存中的数据移动到新空间。

💯代码演示：

#include<stdio.h> 
int main()
{int* p = (int*)malloc(5 * sizeof(int));//20//1 2 3 4 5if (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函数的时候就需要更加注意。

💯代码演示：

#include<stdio.h> 
int main()
{int* p = (int*)malloc(5 * sizeof(int));//20if (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指针的解引用操作

void test()
{int* p = (int*)malloc(INT_MAX);*p = 20;//如果p的值是NULL，就会有问题free(p);
}

对于任何动态内存的开辟（malloc、calloc），都有可能开辟失败，如果开辟失败将会返回空指针，如果我们不加以检查，就会造成对空指针的解引用，实际上malloc是不能开辟 INT_MAX 这么大的一个空间的，所以我们一定要进行检查，正确格式如下：

void test()
{int* p = (int*)malloc(INT_MAX);if (p == NULL){perror("malloc");return 1;}else{*p = 20;//此时p不为空指针free(p);}
}

• 🌰2.对动态开辟空间的越界访问

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释放

void test()
{int a = 10;int* p = &a;free(p);//ok?
}

大家可以返回去看看free函数的介绍，其中说明了如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。上面p指向的并不是动态开辟的空间，不应该使用free也不需要使用free（程序会崩溃），因为对于局部变量而言，具有自动存储期的变量在进入作用域时创建，出作用域时销毁。

• 🌰4.使用free释放一块动态开辟内存的一部分

void test()
{int* p = (int*)malloc(100);p++;free(p);//p不再指向动态内存的起始位置
}

p++之后，不再指向动态内存的起始位置，而是跳过了一个 int 后的位置

 在使用free释放空间的时候，一定要把空间的起始位置传递给free，不能随便传入一个地址，或从半途中来释放其中的一部分，这是不行的，否则程序会崩溃。

• 🌰5.对同一块动态内存多次释放

void test()
{int* p = (int*)malloc(100);free(p);free(p);//重复释放
}

p申请了100字节大小的空间，但是却对这块空间释放了两次，这是不行的，程序也会崩溃。但如果在第一次释放后将p置为 NULL ，那就不会又问题了，因为如果free函数的参数是 NULL 指针，则函数什么事情都不做。

• 🌰6.动态开辟内存忘记释放（内存泄露）

void test()
{int* p = (int*)malloc(100);if (NULL != p){*p = 20;}
}
int main()
{test();while (1);
}

p申请了100个字节大小的空间，但是却忘记了将其释放，这会造成内存泄露，在 test 函数中没有释放，那出了这个函数就连释放的机会也没有了，也就是这块内存再也找不见了，没有还给操作系统。

所以我们再平常写代码的时候尽量要做到谁申请的资源谁去释放，或者给别人去用。如果不去释放，程序结束后，也会由操作系统来自动回收。

🍋知识点四：动态内存经典笔试题分析

 • 🌰1.题目1

#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 指针，如果要拷贝，就会发生内存的非法访问，可能导致程序崩溃。

💯正确代码：

#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

返回栈空间地址的问题

#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;
}

#include <stdio.h>
#include <stdlib.h>
void Test(void)
{int n = 100;return &n;
}
int main()
{Test();return 0;
}

#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;
}

#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;
}

 也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。

C99中，结构中的最后一个元素允许是未知大小的数组，这就叫做【柔性数组】成员。

我们从定义中提取出关键信息：

🔥结构体中，最后一个成员。

🔥最后一个成员是数组，数组没有指定大小。

这样的数组才叫做柔性数组。

例如：

struct S
{char c;int i;int arr[];//柔性数组//或int arr[0]
};

 • 🌰1.柔性数组的特点

🔥结构体中的柔性数组成员前面必须有至少一个其他成员。

🔥sizeof 返回的这种结构体大小不包括柔性数组的内存。

🔥包含柔性数组成员的结构体用malloc()函数进行内存的动态分配，并且分配的内存应该大于结构体的大小，以适应柔性数组的预期大小。

💯代码1：

#include <stdio.h>
struct S
{int i;int arr[];
};
int main()
{printf("%zd\n", sizeof(struct S));//结果为4return 0;
}

 • 🌰2.柔性数组的使用

#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。 

我们也可以用指针的方式实现数组的柔性变化：

#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学习是连贯的，这样更加利于我们的学习和理解以及继续拓展。

 

如果大家觉得有帮助，麻烦大家点点赞，如果有错误的地方也欢迎大家指出~