关于那些柔性数组的知识

简介: 关于那些柔性数组的知识

一.什么是柔性数组

也许你从来没有听说过柔性数组(flexible array)这个概念,但是它确实是存在的。 在C99标准 中,结构中的最后一个元素允许是未知大小的数组,这就叫做『柔性数组』成员。


🌝例子

//写法1
struct st_type
{
    int i ;
    int arr[];  //柔性数组成员
};
//写法2
struct st_type
{
    int i ;
    int arr[0]; //柔性数组成员
};
//对于写法2:有些编译器会报错无法编译
复制代码


二.柔性数组的特点

  • 🛸特点1  :结构中的柔性数组成员前面必须至少一个其他成员。
struct A
{
    int arr[];  //柔性数组成员
    int i;
};
//可能会报错,柔性数组成员前面必须至少一个其他成员
复制代码

  • 🚅特点2:  sizeof 返回的这种结构大小不包括柔性数组的内存。
struct A
{
    int i ; //4
    int arr[];
};
int main()
{
    printf("%d\n",sizeof(struct A)); //4
    return 0;
}
复制代码

  • 🚞特点3:  包含柔性数组成员的结构用malloc ()函数进行内存的动态分配,并且分配的内存应该大于结构的大小,以适应柔性数组的预期大小
struct st_type
{
    int i ;
    int arr[];
};
int main()
{
    struct st_type* p = (struct st_type*)malloc(sizeof(struct st_type)+10*sizeof(int));
    //为数组arr开辟了10个整形大小的空间
    if( p!= NULL)
    {
        int i = 0;
        for(i = 0;i < 10;i++)
        {
            p->arr[i] = i;
            printf("%d ",p->arr[i]);
        }
        p->i = 100;
        printf("%d\n", p->i);
    }
    return 0;
}
复制代码

image.png

 

🎨为数组arr开辟了10个整形大小的空间


三.使用柔性数组的好处

🛍使用柔性数组的例子:

struct st_type
{
    int i;
    int arr[];  //柔性数组成员
};
int main()
{
    struct st_type* p = (struct st_type*)malloc(sizeof(struct st_type) + 10 * sizeof(int));
    //为数组arr开辟了10个整形大小的空间
    int i = 0;
    if (p != NULL)
    {
        for (i = 0; i < 10; i++)
        {
            //为柔性数组成员赋值
            p->arr[i] = i;
            printf("%d ", p->arr[i]);
        }
        p->i = 100;
        printf("%d\n", p->i);
    }
    else
    {
        printf("开辟失败\n");
        return -1;
    }
    //当空间不够时也可以增容
    struct st_type* ptr = (struct st_type*)realloc(p, sizeof(struct st_type) + 20 * sizeof(int));
    if (ptr == NULL)
    {
        printf("扩容失败\n");
        return -1;
    }
    else
    {
        p = ptr;  //把增容空间的地址赋给p
    }
    //使用
    for (i = 10; i < 20; i++)
    {
        p->arr[i] = i;
        printf("%d ", p->arr[i]);
    }
    //释放
    free(p);
    p = NULL;
    return 0;
}
复制代码


💎针对上面的,我们也可以使用动态数组实现

struct st_type
{
    int i ; 
    int* arr;//指向动态开辟的数组  
};
int main()
{
    struct st_type* ps = (struct st_type*)malloc(sizeof(struct st_type));
    ps-> i = 100;
    ps->arr = (int*)malloc(10*sizeof(int));
    int i = 0;
    for(i = 0;i <10;i++)
    {
        ps->arr[i] = i;
        printf("%d ",ps->arr[i]);
    }
    // a空间不够则增容
    int* ptr = (int*)realloc(ps->arr,20*sizeof(int));
    if(ptr == NULL)
    {
        printf("扩容失败\n");
        return -1;
    }
    else
    {
        ps->arr = ptr;
    }
    //使用
    for(i = 10;i<20;i++)
    {
        ps->arr[i] = i;
        printf("%d ",ps->arr[i]);
    }
    //释放!!注意释放顺序
    free(ps->arr);
    ps->arr = NULL;
    free(ps);
    ps = NULL;
    return 0;
}
复制代码


image.png

👒注意!!:要先释放结构体内动态开辟的数组,再释放动态开辟的结构体  


🤎对于上述的写法1和写法2可以实现相同的功能,但是写法1实现由两个好处

💦💨第一个好处:方便内存释放

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

💛第二个好处:有利于访问速度

连续的内存有益于提高访问速度,也有益于减少内存碎片。


四.什么是内存碎片

💓动态分配将不可避免会产生内存碎片的问题,那么什么是内存碎片?内存碎片即“碎片的内存”描述一个系统中所有不可用的空闲内存,这些碎片之所以不能被使用,是因为负责动态分配内存的分配算法使得这些空闲的内存无法使用,这一问题的发生,原因在于这些空闲内存以小且不连续方式出现在不同的位置。因此这个问题的或大或小取决于内存管理算法的实现上。                                                                                [摘自百度百科]

image.png

💢通俗来说,动态开辟空间是随机开辟的,空间之间的间隙就是内存碎片


相关文章
|
7月前
|
编译器 C语言
柔性数组理解
柔性数组理解
48 0
|
编译器 C语言 Python
柔性数组
柔性数组
47 0
|
存储 C语言 C++
深入了解指针,指针数组,数组指针。
深入了解指针,指针数组,数组指针。
|
编译器 C语言 C++
动态内存分配(3)——柔性数组
动态内存分配(3)——柔性数组
|
人工智能 大数据 BI
指针及其应用2——数组指针、字符串指针
指针及其应用2——数组指针、字符串指针
|
7月前
|
编译器
关于柔性数组
关于柔性数组
|
存储 算法 程序员
【C/C++】动态内存&柔性数组
【C/C++】动态内存&柔性数组
130 0
|
编译器 C语言
认识柔性数组
认识柔性数组
|
7月前
|
编译器 C语言
|
编译器 C语言
带你认识柔性数组
小编今天又给大家带来新东西了,相信柔性数组这个名词对于大部分人都比较陌生,那接下来就让我们去认识认识这个新朋友
80 0