目录
感谢各位大佬对我的支持,如果我的文章对你有用,欢迎点击以下链接
🐒🐒🐒 个人主页
🥸🥸🥸 C语言
🐿️🐿️🐿️ C语言例题
🐣🐓🏀 python
常见的动态内存的错误
对NULL指针的解引用操作
c
void test()
{
int* p = (int*)malloc(INT_MAX / 4);
*p = 20;//如果p的值是NULL，就会有问题
free(p);
}如果malloc不做返回值的判断就可能会因为返回空指针导致对空指针解引用
对动态开辟空间的越界访问
c
int main()
{
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);
return 0;
}
对非动态开辟内存使用free释放
c
int main()
{
int a = 10;
int* p = &a;
free(p);
p = NULL;
return 0;
}在动态内存管理(上)我们有提到过,这里的a是栈上开辟的空间,而动态内存开辟的空间是在堆上开辟的,free释放的是堆上的空间,而这里却用free释放栈上的空间,显然是不行的
使用free释放⼀块动态开辟内存的一部分
c
int main()
{
int* p = (int*)malloc(100);
p++;
free(p);//p不再指向动态内存的起始位置
return 0;
}由于p指向的位置发生了变化,导致p不再指向起始位置,而这里是想只是否内存的一部分,这是不对的,如果要释放的话需要将整个内存都释放掉
对同一块动态内存多次释放
c
int main()
{
int *p = (int *)malloc(100);
free(p);
free(p);//重复释放
return 0;
}
当我们在第一次释放后将p变成空指针就不会出问题了
所以每次释放完后要将指针变成空指针是一个好习惯
动态开辟内存忘记释放（内存泄漏）
c
void test()
{
int *p = (int *)malloc(100);
if(1)//条件为真
{
*p = 20;
}
free(p);
p=NULL;
}
int main()
{
test();
while(1);
return 0;
}当我们调用test函数的时候,如果我们在函数内部用malloc开辟了一个空间但是没有释放的话,那么就会发生内存泄露,如果我们想要在跳出函数后还能及时补救,让内存不泄露,我们可以用下面的一种方法
c
int* test()
{
int *p = (int *)malloc(100);
if(1)//条件为真
{
*p = 20;
return p;
}
free(p);
p=NULL;
}
int main()
{
int*a=test();
free(a);
while(1);
return 0;
}当我们将test函数内部开辟的内存地址返回,并用一个a接收时,我们就可以通过a来保存开辟的起始位置,然后将a用free释放掉就不会出现内存泄露
忘记释放不再使用的动态开辟的空间会造成内存泄漏。
切记：动态开辟的空间一定要释放，并且正确释放
柔性数组
C99中，结构中的最后⼀个元素允许是未知大小的数组，这就叫做柔性数组成员
注意:柔性数组一定在结构体中 ,并且是最后一个成员 ,且最后一个成员必须是未知大小的数组
例如：
c
typedef struct st_type
{
int i;
int a[0];//柔性数组成员,未知大小
}type_a;有些编译器会报错无法编译可以改成
c
typedef struct st_type
{
int i;
int a[];//柔性数组成员
}type_a;柔性数组的特点
• 结构中的柔性数组成员前面必须至少一个其他成员。
• sizeof返回的这种结构大小不包括柔性数组的内存。
• 包含柔性数组成员的结构用malloc()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
例如：
c
typedef struct st_type
{
int i;
int a[0];//柔性数组成员
}type_a;
int main()
{
printf("%d\n", sizeof(type_a));//输出的是4
return 0;
}
我们再举一个例子
c
struct S
{
char c;
int i;
int arr[];
};
int main() {
printf("%d", sizeof(struct S));
return 0;
}这里存在着内存对齐的问题,在之前的自定义类型结构体(中)有具体讲过内存对齐的问题
由于char c只占一个字节,int i占4个字节,int arr[]大小未知并且是结构体的最后一个成员,所以满足柔性数组的要求,就不考虑int arr[]
char c作为第一个结构体成员,起始位置应该是从0开始
int i由于是4个字节,所以所在位置应该是从4的最小倍数也就是4开始,往后占4个字节,中间的1 2 3也就浪费掉了(绿色的部分)
最后结构体总大小为最大对齐数的整数倍,由于char c和int i刚好是占了8个字节的大小,所以最后的结果就是8
柔性数组的使用
c
//代码1
#include <stdio.h>
#include <stdlib.h>
int main()
{
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);
return 0;
}这样柔性数组成员a，相当于获得了100个整型元素的连续空间
柔性数组的优势
柔性数组也可以这样来实现
c
//代码2
struct S
{
char c;
int i;
int *a;
};
int main() {
struct S* p = (struct S*)malloc(sizeof(struct S));
p->c = '1';
p->i = 100;
p->a = (int*)malloc (20);
int j = 0;
for (int j = 0; j < 5; j++)
{
p->a[j] = j;
printf("%d ", p->a[j]);
}
return 0;
}柔性数组的实现方案都是在堆上开辟的,因此我们需要用一个结构体类型的指针,然后再对这个指针用malloc来开辟空间,这样*p的的内存空间就是在堆上开辟的
所以我们就可以用malloc去给a开辟空间,然后就可以在开辟的空间里放数据,如果需要再开辟新空间的话我们就用realloc就行了
上述代码1和代码2可以完成同样的功能，但是方法1 的实现有两个好处：
第⼀个好处是：方便内存释放
如果我们的代码是在⼀个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。
用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。
如果我们把结构体的内存以及其成员要的内存⼀次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
第二个好处是：这样有利于访问速度.
连续的内存有益于提高访问速度，也有益于减少内存碎片。
此外柔性数组的柔性还体现在,内存可随时开辟
当我们发现a[]的空间不够时,我们只需要用realloc来再开辟一点空间,因为前面的 char c和int i的内存是固定的,所以我们用realloc开辟的空间只能给a[],也就是说a[]的空间可以随时变化,只有你觉得不够,那么你就可以用realloc给他开辟新的空间
