C语言_struct和union的分析；利用struct创建弹性数组（柔性数组）union判断系统大端小端

struct的分析

思考

空结构体占用多大内存？

struct D
{};

int main()
{
    struct D d1;
    struct D d2;
    printf("%d\n",sizeof(struct D));	//0
    printf("%d,%p\n",sizeof(d1),&d1);	//0,一个地址
    printf("%d,%p\n",sizeof(d2),&d2);	//0,地址跟d1一样
    
    return 0;
}

所以 空结构体不占有内存；

---

由结构体产生柔性数组

• 柔性数组即数组大小待定的数组
• C语言中结构体的最后一个元素可以是大小未知的数组
• C语言中可以由结构体产生柔性数组

struct SofArray
{
    int len;
    int array[];
};

---

柔性数组使用分析

#include<stdio.h>
#include<malloc.h>

typedef struct soft_array
{
    int len;
    int array[];
}SoftArray;

int main()
{
    int i = 0;    
    SoftArray* sa = (SoftArray*)malloc(sizeof(SoftArray) + sizeof(int)*10);
    sa->len = 10;
    for(i=0;i<sa->len;i++)
    {       //赋值
        sa->array[i] = i+1;
    }
    for(i=0;i<sa->len;i++)
    {       //输出验证
        printf("%d ",sa->array[i]);
    }
    free(sa);   //释放内存
    return 0;
}

输出 1 2 3 4 5 6 7 8 9 10

柔性数组的使用

存储斐波拉次数列

//定义柔性数组结构 	typedef struct
//创建柔性数组		creat_soft_array();
//生成斐波拉次数列	fac();
//释放柔性函数		delete_soft_array();
#include<stdio.h>
#include<malloc.h>

//定义柔性数组结构
typedef struct soft_array_
{
    int len;
    int array[];
}SoftArray;

SoftArray* create_soft_array(int size);
void fac(SoftArray* sa);
void delete_soft_array(SoftArray* sa);

int main()
{
    int i = 0;      //循环变量
    SoftArray* sa = create_soft_array(10);//偷懒了 长度直接写10
    fac(sa);        //生成斐波拉次数列

    for(i=0;i<sa->len;i++)
    {
        printf("%d\n",sa->array[i]);
    }
    
    delete_soft_array(sa);      //释放柔性函数
   
    return 0; 
}

//创建柔性数组
SoftArray* create_soft_array(int size)
{
    SoftArray* ret = NULL;
    if(size > 0)
    {   //分配内存
        ret = (SoftArray*)malloc(sizeof(*ret) + sizeof(*(ret->array))*size);
        ret->len = size;
    }
    return ret;
}

//生成斐波拉次数列
void fac(SoftArray* sa)
{
    int i;      //循环变量
    if(NULL != sa )
    {
        if(1 == sa->len)
        {       //只有一项时 第一项为1
            sa->array[0] = 1;
        }
        else
        {       //  从第三项开始算
            sa->array[0] = 1;
            sa->array[1] = 1;
            for(i=2;i<sa->len;i++)
            {
                sa->array[i] = sa->array[i-1] + sa->array[i-2];
            }
        }
    }
}

//释放柔性函数
void delete_soft_array(SoftArray* sa)
{
    free(sa);
}

第41行

ret = (SoftArray*)malloc(sizeof(*ret) + sizeof(*(ret->array))*size);

给array[]分配内存时，用一个sizeof(*(ret->array))，这样写可以直接提出array的类型，修改数组类型时，只修改结构体就好

union的分析

和struct对比一下

struct A
{
    int a;
    int b;
    int c;
};
union B
{
    int a;
    int b;
    int c;
};

int main()
{
    printf("%d\n",sizeof(struct A)); 	//12
    printf("%d\n",sizeof(union B));		//4
}

struct中的每个域在内存中都独立分配空间

union只分配最大域的空间，所有域共享这个空间

---

补充

大小端的概念之前没有了解过，回头写一下补充一下

int时4个字节，十六位数字时0x00000001

如图，在内存里 大端字节序是高地址存低位；小端字节序是低地址存低位。

#include<stdio.h>

int checkSys()
{
    union check
    {
        int i;
        char c;
    }cc;
    
    cc.i = 1;

    return cc.c;
}

int main()
{
    printf("%d\n",checkSys());    //输出1

    return 0;
}

我的window系统时小端存储的；