结构体（结构体内存对齐详情，offsetof的应用，结构体传参，位段，枚举，联合）

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
结构体内存对齐
struct S1
{
    char c1;
    int a;
    char c2;
};
struct S2
{
    char c1;
    char c2;
    int a;
};
struct S3
{
    double d;
    char c;
    int i;
};
struct S4
{
    char c1;
    struct S3 s3;
    double d;
};
int main()
{
    struct S1 s1 = { 0 };
    printf("%d\n", sizeof(s1));//12
    struct S2 s2 = { 0 };
    printf("%d\n", sizeof(s2));//8
    struct S3 s3;
    printf("%d\n", sizeof(s3));//16
    struct S4 s4;
    printf("%d\n", sizeof(s4));//32=8+16+8
    return 0;
}

 

 

如何计算结构体所占空间的大小呢？——首先得掌握对齐规则：
/*
1、第一个成员在与结构体变量偏移为0的地址处
2、其他成员变量（除第一个成员变量以外的变量）要对齐到某个对齐数的整数倍的地址处（即偏移量为对其数的整数倍）才能进行数据的存储
对齐数=编译器默认的一个对齐数与该成员大小的较小值
vs编译器中默认的对齐数为8
3、结构体大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍
4、如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是素有最大对齐数（含嵌套结构体对齐数）的整数倍
*/

存在内存对齐的原因：
/*
1、平台原因：不是所有的硬件平台都能访问任意地址的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2、性能问题：数据结构（尤其是栈）应该尽可能的在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器可能需要作两次内存访问，而对齐的内存访问只需要一次访问。

总结来说：结构体的内存对齐是拿空间来换取时间的做法。
*/

在设计结构体时，我们既要满足内存对齐，又要节省空间，如何做到？
让占用空间小的成员尽量集中在一起。

修改默认对齐数
引用预处理指令#pragma，可以改变我们的默认对齐数
#pragma pack(4)//设置默认对齐数为4
struct S3
{
    char c;
    double d;
    int i;
};
#pragma pack()//取消设置的默认对齐数
struct S4
{
    char c;
    double d;
    int i;
};
int main()
{
    struct S3 s3 = { 0 };
    printf("%d\n", sizeof(s3));//16
    struct S4 s4 = { 0 };
    printf("%d\n", sizeof(s4));//24
    return 0;
}

offsetof——是一个可以用来计算结构体变量存储时的偏移量的一个宏
#include<stddef.h>
struct S4
{
    char c;
    double d;
    int i;
};
int main()
{
    struct S4 s4 = {0};
    printf("%d\n", offsetof(struct S4, c));
    printf("%d\n", offsetof(struct S4, d));
    printf("%d\n", offsetof(struct S4, i));
    return 0;
}

结构体传参
struct S
{
    int a;
    char c;
    double d;
};
//注：结构体传参时，将结构体函数写在结构体定义之前，否则可能出现结构体未定义的情况
void Init(struct S* pc)
{
    pc->a = 4;
    pc->c = 'w';
    pc->d = 3.14;
}
void print(const struct S* pc)
{
    printf("%d %c %lf", pc->a, pc->c, pc->d);
}
int main()
{
    struct S s = { 0 };
    Init(&s);//初始化结构体的函数
    print(&s);//打印结构体的函数
    return 0;
}
/*
函数传参有两种方式。一种是传值，另一种是传址。同样结构体传参也是这两种方式。
函数传参时，参数是需要压栈的，会有时间上和空间上的开销。如果采用传值调用，传的是一个非常大的结构体对象的话，参数压栈的系统开销比较大，
会造成系统性能下降。而传地址只需要占用4\8个字节的空间。
因此结构体传参时应采用传地址的方法。若不想改变原来的值，例如只需要打印的情况下，则只需要在接收的指针前+const即可
*/

位段——结构体的一种可以节省存储空间的一种方法
/*
位段的声明和结构体是类似的，有两个不同：
1、位段的成员必须是int，unsigned int，或signed int，char（属于整形家族）类型
2、位段的成员名后面有一个冒号和一个数字
*/
struct A
{
    int a : 2;//开辟一个整形空间后a只占2个bite位的空间
    int b : 5;//在原来开辟的空间中再划5个bite位的空间给b
    int c : 10;//再在原来的空间中再划10个bite位的空间给c
    int d : 30;//由于原来的空间只剩15（32-17）个bite位，因此重新开辟一个整形空间（4个字节）并将d存储在新开辟的空间中
};
int main()
{
    struct A a = {0};
    printf("%d\n", sizeof(a));//8
    return 0;
}

位段的内存分配
/*
1、位段的空间是按照4个字节（int）或者1个字节（char）的方式来开辟的
2、位段涉及很多不确定因素（C语言官方未给出明确定义），并且位段是不跨平台的，注重可移植的程序应该避免使用位段
*/

 

位段的跨平台问题
/*
1、int位段被当成无符号数还是有符号数是不确定的（由编译器自行判定）
2、位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32.写成27，在16位机器中会出现问题）
3、位段中的成员在内存中从左到右分配还是从右向做分配标准未定义
4、当一个结构包含两个位段，第二个位段成员比较大，无法容纳与第一个位段剩余位时，是舍弃剩余的位还是利用，这是不确定的。
注：位段中的位指的是bite位！
*/
总结：跟结构体相比，位段可以达到同样的效果，并且可以很好的节省空间，但有跨平台的问题存在。

位段的应用——在数据传输时运用位段可以极大的缩小所需传输包的大小

枚举------列举-----把可能的取值一一列举出来（枚举是一种类型）
枚举的定义
enum sex    //enum sex为枚举的类型名
{
    male,
    female,
    secret
};
//{}里面的是枚举的内容，也叫枚举常量。这些枚举常量是有值的，默认从0开始，依次递增1，在定义枚举常量时也可以进行赋值。
enum color
{
    red,
    green=10,
    blue
};
int main()
{
    enum sex s = female;
    enum color c = green;
    printf("%d %d %d\n", male, female, secret);//0 1 2
    printf("%d %d %d\n", red,green,blue);//0 10 11
    return 0;
}

我们可以使用#define来定义常量，为什么还要使用枚举？
枚举的优点
/*
1、增加代码的可读性和可维护性
2、和#define定义的标识符相比，枚举有编译器进行类型检查，更加的严谨
3、防止命名污染（将枚举常量封装起来）
4、便于调试（使用#define时，程序进行预编译时会将定义的内容替换成自己定义的另外的东西，不便于调试时发现问题）
5、使用方便，一次可以定义多个变量
*/

联合（叫联合体也叫共用体）
联合类型的定义
联合也是一种特殊的结构体类型，特征是这些成员公用同一个内存空间（联合体内的变量存储的起始位置相同）
union U
{
    char c;
    int i;
};
int main()
{
    union U un;
    un.i = 0x11223344;
    un.c = 0x55;
    union U u;
    u.i = 0x11223344;
    printf("%x\n", un.i);//11223344
    printf("%x\n", un.c);//55
    printf("%x\n", u.i);//11223344
    printf("%x\n", u.c);//44
    return 0;
}
当只给i赋值时，输出的c的值是i值的切片。当i和c都有初始值时，输出的值是它们各自的值

判断当前计算机是大端存储还是小端存储？
int check()
{
    union u
    {
        int i;
        char c;
    };
    union u un;
    un.i = 1;
    return un.c;
}
int main()
{
    int ret = check();
    if (1 == ret)
        printf("小端存储\n");
    else
        printf("大端存储\n");
    return 0;
}

联合体大小的计算
/*
1、联合体的大小至少是最大成员的大小
2、当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍
*/
union u
{
    char c[5];//所占空间为5个字节。对齐数为数组内元素的类型的大小与8的较小值，即数组的对齐数为1
    int i;//所占空间为4个字节。对齐数为4
};
int main()
{
    union u un;
    printf("%d\n", sizeof(un));//8（本来为5，结果需要是4的整数倍，通过对齐后为8）
    return 0;
}