C语言：动态内存管理

先点赞再观看哦！

学习数据结构之前，一定要对指针、结构体、动态内存管理进行深入学习！

小伙伴们可以看看博主之前的文章！

今天重点介绍动态内存开辟！十分重要哈！

一、为什么要有动态内存开辟？

我们已知的内存开辟方式有什么呢？？

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

但是上述开辟的空间有三个特点：

1、空间开辟的大小是固定的。

2、数组在声明的时候必须指定好数组的长度。

3、都是在栈区创建的，出作用域就会被释放。

       但是有些时候我们对于空间的需求并不仅仅满足于此，可能我们需要的空间大小是在函数运行时才能够知道，那么数组编译时开辟的空间无法满足我们的需求。可能我们希望空间可以不那么快就被释放，那么在栈区上开辟空间也无法满足我们的要求。

    所以需要有动态内存开辟，让程序员可以根据自己的需求申请多大的空间或者是何时释放空间。这样就给代码的书写增添了很多灵活性。

二、perror函数

      我们大多都使用printf来打印一些信息，其它的接口都比较少用。这里介绍一个被我们遗忘的打印输出函数：perror函数。

perror用来将上一个函数发生错误的原因输出到标准设备(stderr)的函数，头文件是<stdio.h>

void perror ( const char * str )

参数 str 所指的字符串会先打印出，后面再加上错误原因字符串。此错误原因依照全局变量errno的值来决定要输出的字符串。

在库函数中有个errno变量，每个errno值对应着以字符串表示的错误类型。当你调用"某些"函数出错时，该函数已经重新设置了errno的值。perror函数只是将你输入的一些信息和errno所对应的错误一起输出。

三、malloc函数

malloc是一个动态开辟内存的函数，头文件<stdlib.h>

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

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

如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要检查！（对p进行判断）

void* malloc (size_t size);

参数类型是size_t size，表示我们需要申请的内存块（空间）的大小，单位是字节,如果size为0，则malloc行为是标准未定义的，具体会怎样取决于编译器。

返回值的类型是void*，说明malloc函数并不知道开辟空间的类型，需要由使用者自己来决定，一般来说，我们在开辟这段空间的时候，其实就已经想好了里面需要存放什么样类型的数据，因此，我们只需将这段空间进行强制类型转换即可。（比如int*p=（int*）malloc（10*sizeof(int)））

四、free函数

C语⾔提供了另外⼀个函数free，专⻔是⽤来做动态内存的释放和回收的,头文件是<stdlib.h>

void free (void* ptr);

void *ptr参数类型的意思是传入我们需要释放的动态开辟空间的起始位置。

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

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

#include <stdio.h>
#include <stdlib.h>
int main()
{
 int num = 0;
 scanf("%d", &num);
 int arr[num] = {0};
 int* ptr = NULL;
 ptr = (int*)malloc(num*sizeof(int));
if(NULL != ptr)//判断ptr指针是否为空
 {
 int i = 0;
 for(i=0; i<num; i++)
 {
 *(ptr+i) = 0；
 }
 }
 free(ptr);//释放ptr所指向的动态内存
 ptr = NULL;//是否有必要？
 return 0;
}

1、手动释放ptr所指向的动态内存有必要吗？？？

答：十分有必要，对于动态开辟的空间如果不主动释放，出了作用域也不会销毁，就可能出现内存泄漏！释放的方式有两种，第一种是使用free手动释放，第二种就是程序结束后操作系统回收，但第二种方法，如果该程序始终不结束，就会十分危险。这说明了使用free手动释放的重要性，我们平时动态开辟空间一定不要忘记free释放掉。

2、ptr置空指针是否有必要？？

答：十分有必要，因为free只会把ptr指向的空间还给操作系统，但是ptr里放的地址依旧是起始地址，为了避免ptr成为野指针，必须要把ptr置为空指针！

五、calloc函数

C语⾔还提供了⼀个函数叫 calloc ， calloc 函数也⽤来动态内存分配。

void* calloc (size_t num, size_t size);

size_t num表示元素个数， size_t size表示元素大小，即该函数的功能是为num个大小为size的元素开辟一块空间，并且把空间的每个字节都初始化为0！

我们会发函函数calloc和malloc十分相似，区别在于calloc会在返回地址之前把申请的空间的每个字节初始化为0！

如果我们需要对申请的空间进行初始化，那么calloc函数是个很不错的选择！

六、relloc函数

• realloc函数的出现让动态内存管理更加灵活。

• 有时会我们发现过去申请的空间太小了，有时候我们⼜会觉得申请的空间过⼤了，那为了合理的时 候内存，我们⼀定会对内存的⼤⼩做灵活的调整。那 realloc 函数就可以做到对动态开辟内存⼤ ⼩的调整。

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

void* ptr 表示需要调整的地址

size_t size表示调整之后的大小

返回值为调整之后的内存的起始位置

realloc在调整内存空间存在两种情况：

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

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

为什么会存在两种情况呢？？

因为我们动态开辟内存的前提就是不能占用别人的空间！！而有些时候如果我们只是直接扩大的话，就很可能会出现这样的问题，所以编译器会根据你的需求去判断。

1、如果你需要的空间可以直接扩大并且不影响别人的空间，那么就会直接扩大，并且relloc返回的依旧是该空间的地址ptr！

2、如果你需要的空间直接扩大后会影响别人的空间，那这个时候编译器就会在内存中去寻找一块新的合适大小的连续空间，先是将原空间的数据拷贝在新空间上，然后释放掉旧空间和旧地址，relloc会返回新的空间的起始地址！

由于上述两种情况，relloc函数的使用就要注意一些。

#include <stdio.h>
#include <stdlib.h>
int main()
{
 int *ptr = (int*)malloc(100);
 if(ptr != NULL)
 {
 //业务处理
 }
 else
 {
 return 1; 
 }
 //扩展容量
 
 //代码1 - 直接将realloc的返回值放到ptr中
 ptr = (int*)realloc(ptr, 1000);//这样可以吗？(如果申请失败会如何？)
 
 //代码2 - 先将realloc函数的返回值放在p中，不为NULL，在放ptr中
 int*p = NULL;
 p = realloc(ptr, 1000);
 if(p != NULL)
{
 ptr = p;
 }
else
{
perror（"relloc"）;
return 1
}
 //业务处理
 free(ptr);
 return 0;
}

如果我们直接将relloc的返回值放到ptr中这样可以吗？如果申请失败会怎样？

答：不可以，因为relloc是在原有的空间上进行调整，在调整之前的空间可能已经存在一些数据了，如果开辟空间失败，那么不仅无法扩容，还会导致原来数据的丢失，因此，我们不能直接用ptr去接受relloc函数的返回值，而是应该先将relloc函数的返回值放在一个临时创建的指针变量里，并进行判断，如果该指针不为空，说明开辟成功了，这时再用ptr去接受比较稳妥。这样哪怕开辟失败，至少可以保证原来的数据不丢失。

七、常见的动态内存的错误

7.1 对NULL指针的解引用操作

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

动态内存可能会开辟失败，如果开辟失败，malloc返回的是NULL指针，这时候使用就会出现问题，所以使用前一定不要忘记判断！！！

void test()
 {
 int *p = (int *)malloc(INT_MAX/4);
if(p==NULL)
{
perror("malloc");
}
 *p = 20;//使用前一定要加以判断，避免使用野指针
 free(p);
 }

7.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);
 }

动态开辟空间就是向内存申请一段空间的使用权，但一定要切记不要访问到没有使用权限的空间！

7.3 对非动态开辟内存呢使用free释放

void test()
 {
 int i = 0;
 int *p = (int *)malloc(10*sizeof(int));
 if(NULL == p)
 {
 exit(EXIT_FAILURE);
 }
 int a = 10;
 *p = &a;
 free(p);//ok?
}

我们在使用指针变量p接受动态开辟的空间时，一定要记住不要随意地去修改p，这样一旦找不到这段空间，就不能及时的释放。上述代码中，a是在栈区创建的，free就会出问题。

7.4 使用free释放一块动态开辟内存的一部分

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

我们不但要注意不要随意去修改接受动态空间起始地址的指针，还要注意不要让该指针发生偏移，否者将无法找到该空间及时释放。

7.5 对同一块动态开辟内存多次释放

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

7.6 动态开辟内存忘记释放（出现内存泄露）

void test()
 {
 int *p = (int *)malloc(100);
 if(NULL != p)
 {
 *p = 20;
 }
 }
int main()
 {
 test();
 while(1);//程序不会停止
 }

对于动态开辟的空间，如果不主动释放，这样就会造成内存泄露，且只有等到程序释放后才能由操作系统回收，但是上述代码中，程序有一个while循环，所以程序一直不结束，这样空间一直不被释放，空间泄露会越来越严重！

八、动态内存经典笔试题分析

8.1 题目1

这个程序有什么问题呢？

问题：

1、GetMemory函数采用的是值传递，无法将malloc开辟出来的空间地址返回到str中，因为值传递对形参的改变不会影响实参，所以调用结束后，str依旧是一个NULL指针。

2、strcpy中使用str就是对空指针进行了解引用，导致了程序的崩溃。

3、没有释放空间，造成了内存泄露。

解决方法：

方式1：使用地址传递，传str的地址，这样就可以修改str的值了，这时候GetMemory函数就需要用二级指针来接受str的地址。

方法2：利用返回值返回开辟空间的起始地址，在函数栈帧销毁前利用寄存器将地址带回来，并用str接收

8.2

8.2 题目2

地址明明成功返回了，那为什么这个程序为什么打印出的是烫烫烫？？

问题：

由于p的空间开辟是在栈区，一旦出了函数空间就会返回给操作系统，地址被成功返回后，str就是一个野指针，因为他指向的空间并不属于我们。（典型的返回栈空间地址的问题）

解决方法：

我们希望p指向的空间不被销毁，所以可以使用static修饰，这样可以使得该空间创建在静态区，就不会被释放了。

此题也可以利用函数栈帧的创建和销毁进行分析。

8.3 题目3

这段代码确实得到我们想要的结果，但是也存在一定的问题：

1、因为malloc开辟空间可能会失败，未进行判断就使用，可能会出现野指针导致非法访问。

2、对动态开辟的空间没有free。

解决方法：

1、每次开辟动态空间必须加以判断，确保不为NULL才可以使用。

2、对开辟的空间一定要记得释放！

8.4 题目4

问题：

1、str指向的空间已经被释放掉了，所以此时str是一个野指针，strcpy相当于对str进行解引用，属于非法访问。

2、开辟的空间没有判断是否为NULL，并且没有free。

要十分注意，虽然我们非法访问了，但是程序一样运行成功了，但这只是说但这并不意味着我们的行为是可以接受的，代码成功的原因是内存管理并不能阻止非法访问任何地址，只是这种访问可能带来不可预测的后果，所以我们一定要规范自己的行为！！

九、柔性数组

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

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

typedef struct st_type

{

int i;

int a[0];//柔性数组成员 也可以将0省略

}type_a;

9.1 柔性数组的特点

• 结构中的柔性数组成员前⾯必须至少⼀个其他成员。

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

• 包含柔性数组成员的结构⽤malloc ()函数进⾏内存的动态分配，并且分配的内存应该⼤于结构的⼤ ⼩，以适应柔性数组的预期大小。

typedef struct st_type
{
 int i;
 int a[0];//柔性数组成员
}type_a;
int main()
{
 printf("%d\n", sizeof(type_a));//输出的是4
 return 0;
}

输出结果：4

9.2 柔性数组的使用

#include <stdio.h>
#include <stdlib.h>
typedef struct st_type
{
	int i;
	int a[];//柔性数组成员
}type_a;
int main()
{
int i = 0;
 type_a *p = (type_a*)malloc(sizeof(type_a)+100*sizeof(int));
 //如果是type_a p={0},那么该变量并没有柔术数组空间的大小
//所以必须用结构体指针变量，这样才能进行malloc对柔术数组扩容，并且接收返回的地址！！
 p->i = 100;
 for(i=0; i<100; i++)
 {
 p->a[i] = i;
 }
 free(p);
 return 0;
}
//次数数组a相当于获得了100个整型元素的空间！

    一定要注意，如果在结构体中使用柔性数组，就一定要动态内存开辟，否则就没有柔性数组空间的大小，因此为了能够返回开辟空间的地址，一般我们在使用时创建结构体指针变量。

9.3 柔性数组的优势

上述的 type_a 结构也可以设计为下⾯的结构，也能完成同样的效果。

#include <stdio.h>
#include <stdlib.h>
typedef struct st_type
{
 int i;
 int *p_a;//动态数组
}type_a;
int main()
{
 type_a *p = (type_a *)malloc(sizeof(type_a));//为了把结构体变量开辟在堆区
 p->i = 100;
 p->p_a = (int *)malloc(p->i*sizeof(int));
 
 //业务处理
 for(i=0; i<100; i++)
 {
 p->p_a[i] = i;
 }
 
 //释放空间
 free(p->p_a);
 p->p_a = NULL;
 free(p);

相比柔性数组的方法，动态数组的方法需要动态开辟内存两次，因为*p_a的扩容是在堆区上开辟的，所以为了保证结构体其他变量也在堆区开辟，创建变量的时候也要为结构体在堆区开辟空间！而且最后释放2次，1次是释放动态数组的空间，1次是释放结构体的空间。

动态数组同样可以完成这个功能，那为什么c99还要引入柔性数组呢？因为柔性数组有两个好处。

1、方便内存释放

如果我们的代码是在⼀个给别⼈⽤的函数中，你在⾥⾯做了⼆次内存分配，并把整个结构体返回给用户。用户调⽤free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能 指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存⼀次性分配好了，并返 回给用户⼀个结构体指针，用户做⼀次free就可以把所有的内存也给释放掉。

2、这样有利于访问速度

连续的内存有益于提高访问速度，也有益于减少内存碎⽚。（其实，我个⼈觉得也没多高了，反正你跑不了要⽤做偏移量的加法来寻址）

9.4 扩展

9.4.1 内存碎片

动态内存开辟的过成中形成的空间中间可能有缝隙，也就说有些内存没有用到，动态开辟次数越多，留下的空隙可能也会越多，我们把这个空隙叫做内存碎片。所以我们平时在动态开辟的时候，倾向于尽可能少地次数就完成工作，这样可以尽量减少内存碎片，避免内存浪费。

9.4.2 内存池

在真正使用内存前，先提前申请分配一定数量、大小相等地内存块留作备用，当有新地需求是时，就从其中分出一部分内存块，若内存块不够，就再申请新的连续地内存。

优点是是内存分配地效率得到提升，特点是避免了内存指针。

可以看看这个博主写的。

一文看懂内存池原理及创建（C++实现）_c++ 内存池机制-CSDN博客

9.4.3 局部性原理

在 CPU 访问存储设备时，无论是存取数据抑或存取指令，都趋于聚集在一片连续的区域中，这就被称为局部性原理。
时间局部性（ Temporal Locality ） ：如果一个信息项正在被访问，那么在近期它很可能还会被再次访问。 比如循环、递归、方法的反复调用等。
空间局部性（ Spatial Locality ） ：如果一个存储器的位置被引用，那么将来他附近的位置也会被引用。

9.4.4 文章拓展

C语言结构体里的成员数组和指针 | 酷 壳 - CoolShell

十、总结C/C++中程序内存区域划分

C/C++程序内存分配的⼏个区域：

1. 栈区（stack）：在执⾏函数时，函数内局部变量的存储单元都可以在栈上创建，函数执⾏结束时 这些存储单元⾃动被释放。栈内存分配运算内置于处理器的指令集中，效率很⾼，但是分配的内 存容量有限。 栈区主要存放运⾏函数⽽分配的局部变量、函数参数、返回数据、返回地址等。 2. 堆区（heap）：⼀般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配⽅ 式类似于链表。

3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。

4. 代码段：存放函数体（类成员函数和全局函数）的⼆进制代码。

文章不易，点赞收藏关注呗！

文章来源地址https://www.toymoban.com/news/detail-814096.html

到了这里，关于C语言：动态内存管理的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！