【深度解剖 C语言动态内存分配】

最新推荐文章于 2023-09-22 12:41:08 发布

苏宝银

最新推荐文章于 2023-09-22 12:41:08 发布

阅读量431

点赞数 1

分类专栏： C语言知识点详解文章标签： c语言 java jvm

本文链接：https://blog.csdn.net/qq_63188326/article/details/130788812

版权

C语言知识点详解专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1.为什么要进行动态内存分配？

我们已经掌握的内存开辟方式有：

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

上述两种内存开辟方式都属于静态内存开辟。他们开辟的空间大小是固定的。数组在声明的时候，必须指定数组的长度，它所需要的内存在编译时分配。但是有时我们需要的空间大小在程序运行时才能知道，需要临时开辟空间。比如，通讯录C语言程序，增加通讯录的人的信息时，也就是在运行时，发现之前申请的内存空间不够，这个时候就需要程序在运行过程中开辟空间。这是静态内存空间开辟做不到的。所以我们引入动态内存分配的概念。

C语言变量开辟空间的区域图：
在这里插入图片描述
小tips:
栈区和静态区的变量，分配的空间是固定的，正如我开始举的那两个例子。栈区变量的生命周期和作用域都和它所在的函数有关。它仅作用于它所在的函数内部，函数调用结束，开辟的空间就被收回。静态区的变量，有静态变量（static修饰)、全局变量。静态变量和全局变量的生命周期和程序一样长，程序结束，空间收回。堆区是进行动态内存分配，动态的内存分配，无论是将它分配给局部变量还是全局变量，变量可以因为出了作用域等原因被销毁，但是空间不会被回收。动态分配的内存只有free释放和程序结束，系统自动回收两种方式。

2.动态内存函数的介绍

malloc和free

C语言提供了一个动态内存分配的函数malloc

void*malloc(size_t size);
//向内存空间也就是堆区申请了size个字节的连续空间，并且返回指向这个连续空间的空指针

malloc函数特点：

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

void free(void* ptr);

free函数的特点：

1.free函数用来释放动态开辟的内存
2.如果参数ptr是空指针时，那么free函数的行为是未定义的。（也就是报错不执行）
3.如果参数ptr是NULL指针时，则函数什么事情也不用做。

注意：malloc和free函数都声明在<stdlib.h>中。
例子：

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
int main()
{
//开辟20个字节的空间
int *p = (int *)malloc(20);
//判断是否开辟成功
if(p == NULL)
{
printf("%s\n",strerror(errno));
return 1;
}
//使用
int i = 0;
for(i = 0; i<5; i++)
{
*(p+i) = i;
}
//释放
free(p);
//将指针置为空
p = NULL;
}

注意：

//释放
free(p);
//将指针置为空
p = NULL;

这两步是非常关键且必不可少的。free（p)这个动作是将p指向的这块连续的空间还给操作系统。使这块空间不再属于我们。而指针p仍然是指向这块空间的。如果有人使用了指针p依然可以访问到这块空间，此时这块空间已经被释放了，就会造成非法访问。所以在free之后应该将p置为空（也就是让p忘记这块空间所在的位置）

calloc

C语言还提供了一个函数叫做calloc,calloc函数也用来动态分配内存。

void *calloc(size_t num,size_t size);

calloc函数的特点：

1.为num个元素,每个元素大小为size个字节的元素开辟一块儿空间,并且把空间的每个字节初始化为0.
2.与函数malloc的区别只在于calloc函数会在返回地址之前把申请的空间的每个字节初始化为0.

#include<stdlib.h>
int main()
{
int *p = calloc(10,sizeof(int));
if(p!=NULL)
{
//使用空间
}
free(p);
p = NULL;
return 0;
}

calloc初始化的结果查看:
在这里插入图片描述
这里:calloc函数申请了4个整型的空间,并将每个字节都初始化为0.

realloc

realloc函数的出现让动态内存管理更加灵活.有时候我们觉的分配的空间太小了,有时候又觉得分配的空间太大了.那为了合理的分配内存,我们需要对内存的大小进行灵活的调整.那realloc函数就可以做到对动态开辟内存大小的调整.

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

realloc函数的特点:

1.ptr是需要被调整的内存地址
2.size是调整之后的大小
3.返回值为调整之后的内存的起始位置.
4.这个函数调整原内存空间大小的基础上,还会将原来的内存中的数据移动到新的内存空间.
5.realloc函数在调整内存空间是存在两种情况.
情况一:原有的空间之后有足够大的连续的空间
情况二:原有的空间之后没有足够大的连续的空间
图解

情况一:
当是情况一的时候,要扩展内存就直接在原有的内存之后追加空间,原来的空间的数据不发生变化.
情况二:
当是情况二的时候,原有的空间之后没有足够大的空间,扩展的方法是:在堆空间上另外找一个合适大小的连续空间来使用,这样该函数返回的是一个新的内存地址.

举个例子

#include<stdio.h>,
int main()
{
int *ptr = (int*)malloc(100);
if(ptr! = NUll)
{
//业务处理
}
else
{
exit(EXIT_FAIURE);
}
//扩展容量
//代码1
ptr = (int*)realloc(ptr,1000);//这样可以吗?(如果申请失败会如何?)

//代码2
int *p = NULL;
p = realloc(ptr,1000);
if(p!=NULL)
{
ptr = p;
}
//业务处理
free(ptr);
return 0;

注意看:
代码一直接使用指向原地址的指针去接受realloc函数的返回值,如果分配失败,返回NULL,原指针被置空.连最初分配的空间都找不到了.
代码二:使用一个新的指针来接受realloc函数的返回值,并判断,如果新增空间成功,则将新地址赋给原指针.

3.常见的动态内存错误

3.1对NULL指针的解引用操作

void test()
{
int *p = (int*)malloc(20);
*p = 20;
free(p);

malloc分配空间后，若分配失败，将返回null指针，这里没有判断就对指针p解引用，若p为空指针，对空指针解引用，不知道要访问多少个字节，就会出问题。

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

注意看：这里的malloc函数只开辟了10个整型的连续空间，当i=10的时候，p+i指向的空间是第11个字节的空间。而第11个字节的空间并不属于我们。指针越界访问，属于非法访问内存。

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

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

free函数用于动态分配空间的释放，动态内存空间是在堆上开辟的，而此处的内存空间是在栈上开辟的。free释放空间会报错。

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

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

malloc函数动态内存开辟了100个字节的空间，并且将空间的首地址交给了p指针，p++后p指针不再指向内存的最初位置。free§释放的是由p指向的位置往后的开辟的空间。而p之前的空间没有释放，造成内存泄露

3.5 对同一块内存多次释放

void test()
{
int*p = (int*)malloc(100);
free(p);
free(p);//对同一块内存空间的多次释放导致报错
}

修正代码：

void test()
{
int *p = (int*)malloc(100);
free(p);
p = NUll;
free(p);
}

在释放内存后，将指针置为空。在后续的代码中，就算无意间再次释放p也没事。因为指针p为空，不指向任意一块内存。

3.6 动态开辟内存忘记释放

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

注意：这里的指针变量p是一个局部变量，局部变量是在栈上创建的，它指向malloc开辟的100个字节的空间的首地址。而malloc开辟的空间是在堆上开辟的。test()函数调用结束后，局部变量p销毁了，没有人再记得malloc开辟的那块空间的位置，malloc开辟的空间只能free释放，或者程序结束，空间自动回收。由于没有人记得空间的位置，所以没有办法free，而test（）函数语句之后，是一个死循环，证明程序调用不会主动结束。空间不会因程序的主动结束而回收。所以该操作会造成内存泄露。+

4.几个经典的笔试题

4.1题目一

void GetMemory(char* p)
{
p = (char*)malloc(100);
}
void test(void)
{
char* str = NULL;
GetMemory(str);
strcpy(str,"hello world");
printf(str);
}

两个错误：
错误一：内存空间的泄露。注意看GetMemory函数传参，传的不是地址，而是变量，属于值传参，值传参时，形参是实参的一份临时拷贝，不属于实参。GetMemory函数中，p指向了malloc动态开辟的空间。而p只是一个局部变量，出了函数就销毁了。于是malloc动态开辟的空间的首地址又没有人记得了。造成空间泄露。
错误二：无效访问，在写入时报错。对p指针解引用得到的是NULL，也就是0地址，0地址位置的空间在内存中只能读入，不允许访问。

4.2题目二

char *GetMemory(void)
{
char p[] = "hello world";
return p;
}
void test(void)
{
char*str = NULL;
str = GetMemory();
printf(str);
}

注意看：GetMemory函数中的数组p是一个临时变量，出了函数之后就销毁了，给这个数组的内存空间也被收回了。但是这块空间的首地址被返回了，并且交给了str指针，printf(str);对str指向的内存空间的访问属于非法访问，并且此时的str是一个野指针。

4.3题目三

void GetMemory(char**p, int num)
{
*p = (char*)malloc(num);
}
void test(void)
{
char *str = NULL;
GetMemory(&str,100);
strcpy(str,"hello");
printf(str);
}

错误：使用动态开辟的空间后，没有将其释放
修正代码：

void GetMemory(char**p, int num)
{
*p = (char*)malloc(num);
}
void test(void)
{
char *str = NULL;
GetMemory(&str,100);
strcpy(str,"hello");
printf(str);
free(str);
str == NULL;
}

4.4题目四

void test(void)
{
char* str = (char*)malloc(100);
strcpy(str,"hello");
free(str);
if(str! = NULL)
{
strcpy(str,"world");
printf(str);
}
}

错误：非法访问内存。free这个动作释放了str指针指向的内存空间。这块空间虽然还给了操作系统，但是它的地址依旧保存在str中，所以str!=NULL. if的判断成立。strcpy拷贝时，访问了str指向的空间。由于它指向的空间已经还给操作系统，所以它属于非法访问内存。

void test(void)
{
char* str = (char*)malloc(100);
strcpy(str,"hello");
free(str);
str = NULL;
if(str! = NULL)
{
strcpy(str,"world");
printf(str);
}
}

5.C/C++程序的内存开辟

在这里插入图片描述
C/C++程序内存分配的几个区域：

1.栈区（stack)：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
2.堆区(heap):一般由程序员分配释放，若程序员不释放，程序结束时可能被OS回收。分配方式类似于链表。
3.数据段（静态区）（static)存放全局变量、静态数据。程序结束后由系统释放。
4.代码段：存放函数体（类成员函数和全局函数）的二进制代码。

加深static的了解：

实际上普通的局部变量是在栈区分配空间的,栈区的特点就是在上面创建的变量出了作用域就销毁.但是被static修饰的变量存放在数据段(静态区),数据段的特点是在上面创建的变量,直到程序结束才销毁.所以生命周期会变长.

小tips:

realloc(void*str,size_num);

当指针为空时,此时的realloc才相当于malloc.

6.柔性数组

C99中,结构体的最后一个成员允许是未知大小的数组,这就是柔性数组成员.
例如:

typedef struct st_type
{
int i = 0;
int a[0];//柔性数组
}type_a;

有些编译器会报错无法编译可以改为:

typedef struct st_type
{
int i = 0;
int a[];//柔性数组
}type_a;

6.1 柔性数组的特点

1.结构体中的柔性数组成员的前面必须至少包含一个其它成员
2.sizeof返回的这样结构大小不包括柔性数组的内存.
3.包含柔性数组成员的结构用malloc()函数进行内存的分配.并且分配的内存应该大于结构体的大小,以适应柔性数组的预期大小.

例如:

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

6.2 柔性数组的使用

//代码一
typedef struct st_type
{
int i = 0;
int a[0];//柔性数组成员
}type_a;
int i = 0;
type_a*p = (type_a*)malloc(sizeof(type_a)+100*sizeof(int));//结构体的大小+柔性数组的大小
//业务处理
p->i = 100;
for(i = 0; i<100; i++)
{
p->a[i] = i;
}
free(p);
}

这里的柔性数组成员a,相当于获得了100个整型元素大小的连续空间

6.3 柔性数组的优势

上述的type_a结构也可以设计为:

typedef struct st_type
{
int i = 0;
int *p_a;
}type_a;
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_a);
p_a = NULL;
free(p);
p =NULL;

上述的两段代码:它们实现的功能相同,但是代码1有两个好处:
好处一:方便代码释放

代码一只需要free一次.如果我们的代码是在一个给别人用的函数中,你在里面做了两次内存分配,并把整体结构体返回给用户.用户调用free可以释放结构体,但是用户并不知道这个结构体内的成员也需要free,所以你不能指望用户来发现这个事情.所以,如果我们把结构体以及其成员要的内存一次性分配好,并返回给用户一个结构体指针,用户做一次free就可以把所有的内存都释放掉.

好处二:有利于提高访问速度

连续的内存有利于提高访问速度,有利于减少内存碎片.

总结

本篇中,我们讲了动态内存分配的相关函数malloc,calloc,realloc.以及常见的动态内存分配错误.包括:对NULL指针的解引用错误,对动态开辟内存的越界访问,对非动态开辟内存使用free释放,使用free函数释放一块动态开辟空间内存的一部分.对同一块内存多次释放,以及动态开辟内存忘记释放等多个常见的错误.以及几个经典的笔试题.最后还讲了柔性数组的概念优势及使用.

C语言内容全面深入持续更新中~想了解更多请点击我的主页关注收藏不迷路~

苏宝银

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
【深度解剖 C语言动态内存分配】

深层次的C语言是这样的. 动态内存分配的相关函数malloc,calloc,realloc.以及常见的动态内存分配错误.包括:对NULL指针的解引用错误,对动态开辟内存的越界访问,对非动态开辟内存使用free释放,使用free函数释放一块动态开辟空间内存的一部分.对同一块内存多次释放,以及动态开辟内存忘记释放等多个常见的错误.以及几个经典的笔试题.最后还讲了柔性数组的概念优势及使用.
复制链接

扫一扫