请耐心看完,看完后就会对内存中的空间划分有了更深刻的认识!
我们知道,任何一个变量的创建都会向内存申请空间用来存放,而在内存中的空间又划分为几个区域、最主要划分为:栈区、堆区、静态区
而我们平常创建变量或者数组,如下:
int a=0;
int arr[1000];
这里的a与arr都是在栈区开辟空间的,而栈区的特点之一就是出了作用域就会自动销毁
,所以它们的生命周期只要出了所在的作用域就结束了。因此在栈区上开辟空间的变量一般都是:局部变量、形参
这种
而且我们发现,在栈区上开辟空间的一些变量,它们的大小都是固定的
,就比如上文的数组arr,它的大小就是固定的4000字节,但是我们可以想一下,有时候在使用它的时候,并不需要这么多的空间,可能仅仅只需要10个整形大小的空间,而后面的990个整形空间都会被浪费掉,着实是可惜呀!
那我们不禁美滋滋的会这么想象,会不会存在我们想用多少空间,就开辟多少空间的可能呢?答案是有的!
我们上面提到了内存中还划分有堆区,而堆区的特点之一就是:可以按自己的需求开辟空间,并且该空间出了作用域不会自动销毁,只能人工销毁
,这就实现了我们想要的需求。
那么应如何在堆区开辟空间呢?这里就涉及到了以下讲到的几个函数:malloc、realloc、calloc,还有用来释放空间的free
可能有人还会疑问,上面的静态区是干嘛的,所谓的静态区,它的特点是:永恒存在、生命周期一直到程序结束所以在静态区开辟空间的变量一般为:常量、const修饰的常变量、全局变量、以及static修饰的静态 全局/局部 变量。
我们上面已经讲过了,动态内存分配是在堆区完成、并且空间是由程序员自己释放,因此切记,malloc、calloc、realloc与free都是成对出现的
!
首先是malloc,向内存申请size字节的空间,然后返回该空间的起始地址。
使用演示
#include<stdio.h>
#include<stdlib.h>//头文件
int main()
{
int* p = (int*)malloc(10*sizeof(int));
//开辟10个整形大小的空间(40byte),然后用指针p来接收该空间的起始地址
//因为p是int*类型的,所以将该空间强制类型转换成(int*),保证用来接收的指针类型与开辟空间的类型一致
if (p == NULL)
{
perror("malloc");
return 1;
}
//对空间进行一个判断,假如开辟失败,打印错误,并返回。return 1表示非正常返回、
//开辟成功正常使用
//...
free(p);//使用完一定记得释放!(从哪里申请,从哪里释放,后面会将注意事项)
p = NULL;//将指针置空
return 0;
}
这里一定要对p进行判断,因为假如空间开辟失败,p就是一个空指针,后面假如对p进行操作与使用,很可能会出现很大的问题!
calloc与malloc很像,使用也基本相同,只不过它是这样使用的:开辟num个大小为size的空间,并且将空间的每个字节都初始化为0,而malloc开辟的空间里面的值是随机值。
使用演示
#include<stdio.h>
#include<stdlib.h>//头文件
int main()
{
int* p = (int*)calloc(10,sizof(int));
//开辟个10个空间,每个空间大小为一个整形大小(一共40byte),然后用指针p来接收该空间的起始地址
//因为p是int*类型的,所以将该空间强制类型转换成(int*),保证用来接收的指针类型与开辟空间的类型一致
if (p == NULL)
{
perror("calloc");
return 1;
}
//对空间进行一个判断,假如开辟失败,打印错误,并返回。return 1表示非正常返回、
//开辟成功正常使用
//...
free(p);//使用完一定记得释放!(从哪里申请,从哪里释放,后面会将注意事项)
p = NULL;//将指针置空
return 0;
}
有时会我们发现过去申请的空间太小了,有时候我们又会觉得申请的空间过大了,那为了合理的时候内存,我们一定会对内存的大小做灵活的调整。
realloc 函数就可以做到对动态开辟内存大小的调整
。
但是会存在原地扩容和异地扩容两种情况
使用演示
#include<stdlib.h>//头文件
#include<stdio.h>
int main()
{
int* p = (int*)malloc(40);//开辟40byte
//判断是否开辟成功
if (p == NULL)
{
perror("malloc fail");
return 1;
}
//使用p指向的空间
for (int i = 0; i < 10; i++)
{
*(p + i) = i;
}
for (int i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
//0 1 2 3 4 5 6 7 8 9
//扩容,用ptr接收新空间起始地址
int* ptr = (int*)realloc(p, 80);
if (ptr != NULL)
{
//扩容成功后,让p指向ptr,ptr置空
p = ptr;
ptr = NULL;
}
//使用
for (int i = 0; i < 20; i++)
{
*(p + i) = i;
}
for (int i = 0; i < 20; i++)
{
printf("%d ", *(p + i));
}
//使用完释放
free(p);
p = NULL;
return 0;
}
我们在使用动态内存分配时总是难免会犯一些不必要的错误,毕竟人非圣贤,孰能无过,接下来我将列举这些常见的错误,以警示避免! 1、对空指针的解引用 例:
void test()
{
int *p = (int *)malloc(INT_MAX/4);
*p = 20;//如果p的值是NULL,就会有问题,error!
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的时候越界访问,error!
}
free(p);
}
3、对非动态开辟内存使用free释放 例:
void test()
{
int a = 10;
int *p = &a;
free(p);//error!
}
4、使用free释放一块动态开辟内存的一部分 例:
void test()
{
int *p = (int *)malloc(100);
p++;
free(p);//p不再指向动态内存的起始位置,error!
}
5、 对同一块动态内存多次释放 例:
void test()
{
int *p = (int *)malloc(100);
free(p);
free(p);//重复释放
}
6、 动态开辟内存忘记释放(内存泄漏) 例:
void test()
{
int *p = (int *)malloc(100);
if(NULL != p)
{
*p = 20;
}
//忘记释放!error!
}
int main()
{
test();
while(1);
}
动态开辟的内存空间不使用的时候一定要记得释放!
接下来通过一些经典笔试题的讲解来加深对动态内存分配的理解: 题目一:解释运行Test函数出现的结果
void GetMemory(char *p) { p = (char *)malloc(100); } void Test(void) { char *str = NULL; GetMemory(str, 100); strcpy(str, “hello”); printf(str); }
分析:
在这里,str首先置空,把str传过去,用指针p来接收,然后p再指向新开辟的空间,再把hello拷贝到该空间,接着打印。 听起来好像没什么毛病,但是我们忽略了以下几点!首先,malloc开辟的空间并没有free,造成内存泄漏,这时最明显的错误! 然后,GetMemory这里只是传址调用,也就是说,p确实指向了那块空间,但是实际上str并没有指向,这里只是把str=NULL的值,传了过去,p=NULL,然后对p进行操作,我们知道,传值调用,形参的改变不会影响实参!所以str仍是NULL,而strcpy一个空指针,就涉及到了对空指针的解引用,ERROR! 这两处错误最为致命!
作为修改,我们可以这样改正:
void GetMemory(char** p)//一级指针的地址用二级指针来接收
{
*p = (char*)malloc(100);//*p 等价于*&str,等价于str,即str=......
}
void Test(void)
{
char* str = NULL;
GetMemory(&str);//传址调用,对形参的修改会影响实参
strcpy(str, "hello");
printf(str);
free(str);//释放
str = NULL;
}
笔试题二:以下代码运行结果:
#include<stdlib.h> #include<stdio.h> #include<string.h> char* Getmemory() { char p[] = “hello world!”; return p; } void test() { char* str = NULL; str = Getmemory(); printf(str); } int main() { test(); return 0; }
看起来没什么问题,str来接收Getmemory返回的地址,然后打印,按理来说应该是hello world!,但是,真实结果却是一堆乱码
这是为什么呢? 分析:
在前言那块,讲到了栈区的特点就是出作用域后会自动销毁,我们看这里的p,p是数组名,表示数组首元素的地址,在这里即字符’h‘的地址,然后返回该地址用str来接收,但是!别忘记p是个局部变量,局部变量在栈区开辟空间,出作用域后会自动销毁!也就是说 虽然传给了h所在的地址,但是当它传过去的那一刻,p所在的空间就自动销毁,而str依然记着那块空间,但是此时的那块空间已经不属于p了,这就造成了野指针的访问,谁也不知道那块空间销毁后里面是什么,所以打印乱码。
图解:
张三 and 李四
举个张三与李四的故事来方便大家理解(🤭),张三与李四是一对情侣,这一天,好不容易放假,李四就去酒店开了个房,然后把房间号告诉了李四,然后自己在房间里等他,等啊等,发现张三一直在打lol,还没有过来,就气的也没有告诉张三,就把房间退了,然后房间里现在住着王二麻子和他对象,假如张三再去找李四,确实,他记得房间号码,也能找到位置,但是他不知道房间里已经换人了,此时他不打开房间还好,假如打开的话…(狗头保命🐕)
这里的张三就好比题目里的str,p->酒店房间,p的地址->房间号码,空间销毁之前里面住的是李四,销毁后住的王二麻子。 str虽然能找到p之前指向的空间,但空间里的内容早已换了~
定义
柔性数组这个名词听起来很高大上,但其实并没有什么特殊的,那么它是什么呢?简单来说,就是结构体中的最后一位成员为数组,并且大小未知。
举个栗子:
typedef struct st_type
{
int i;
int a[];//柔性数组成员,也可以写成int a[0]
}type_a;
这里的数组a,是结构体最后一位成员,并且大小未知,所以它就是所谓的柔性数组.
特点 1、结构中的柔性数组成员前面必须至少一个其他成员。 2、sizeof 返回的这种结构大小不包括柔性数组的内存。 3、包含柔性数组成员的结构用malloc ()函数进行内存的动态分配,并且分配的内存应该大于结构的大小,以适应柔性数组的预期大小。
使用
#include<stdlib.h>
#include<stdio.h>
struct S
{
int i;
int a[];
};
int main()
{
struct S* p = (struct S*)malloc(sizeof(struct S) + 100 * sizeof(int));//为柔性数组a提供100个整形空间
if (p == NULL)
{
perror("malloc fail");
return 1;
}
p->i = 100;
for (int j = 0; j < 100; j++)
{
p->a[j] = j;
}
free(p);//释放
p = NULL;
return 0;
}
这样有什么好处呢?我个人觉得,首先这个柔性数组它的空间可以按照自己的需要来开辟,不会造成大量的空间浪费,还有就是方便释放,直接一次性free整个结构体指针即可。
end 生活原本沉闷,但跑起来就会有风!