动态内存管理(下)

内存管理(下)"/>

动态内存管理(下)

目录

• 常见的动态内存的错误
• • 对NULL指针的解引用操作
  • 对动态开辟空间的越界访问
  • 对非动态开辟内存使用free释放
  • 使用free释放⼀块动态开辟内存的一部分
  • 对同一块动态内存多次释放
  • 动态开辟内存忘记释放（内存泄漏）
• 柔性数组
• • 柔性数组的特点
  • 柔性数组的使用
  • 柔性数组的优势

感谢各位大佬对我的支持,如果我的文章对你有用,欢迎点击以下链接
🐒🐒🐒 个人主页
🥸🥸🥸 C语言
🐿️🐿️🐿️ C语言例题
🐣🐓🏀 python

常见的动态内存的错误

对NULL指针的解引用操作

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

如果malloc不做返回值的判断就可能会因为返回空指针导致对空指针解引用

对动态开辟空间的越界访问

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

int main()
{int a = 10;int* p = &a;free(p);p = NULL;return 0;
}

在动态内存管理(上)我们有提到过,这里的a是栈上开辟的空间,而动态内存开辟的空间是在堆上开辟的,free释放的是堆上的空间,而这里却用free释放栈上的空间,显然是不行的

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

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

由于p指向的位置发生了变化,导致p不再指向起始位置,而这里是想只是否内存的一部分,这是不对的,如果要释放的话需要将整个内存都释放掉

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

int main()
{int *p = (int *)malloc(100);free(p);free(p);//重复释放return 0;
}

当我们在第一次释放后将p变成空指针就不会出问题了

所以每次释放完后要将指针变成空指针是一个好习惯

动态开辟内存忘记释放（内存泄漏）

void test()
{int *p = (int *)malloc(100);if(1)//条件为真{*p = 20;}free(p);p=NULL;
} 
int main()
{test();while(1);return 0;
}

当我们调用test函数的时候,如果我们在函数内部用malloc开辟了一个空间但是没有释放的话,那么就会发生内存泄露,如果我们想要在跳出函数后还能及时补救,让内存不泄露,我们可以用下面的一种方法

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中，结构中的最后⼀个元素允许是未知大小的数组，这就叫做柔性数组成员
注意:柔性数组一定在结构体中,并且是最后一个成员,且最后一个成员必须是未知大小的数组

例如：

typedef struct st_type
{int i;int a[0];//柔性数组成员,未知大小
}type_a;

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

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

柔性数组的特点

• 结构中的柔性数组成员前面必须至少一个其他成员。
• sizeof返回的这种结构大小不包括柔性数组的内存。
• 包含柔性数组成员的结构用malloc()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
例如：

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

我们再举一个例子

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

柔性数组的使用

//代码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个整型元素的连续空间

柔性数组的优势

柔性数组也可以这样来实现

//代码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给他开辟新的空间