大家好，我是苏貝，本篇博客带大家了解结构体和位段以及枚举，如果你觉得我写的还不错的话，可以给我一个赞👍吗，感谢❤️
这是这个系列的第二篇，上一篇详细介绍了结构体的基本知识，详情请点击
一.结构体
1.1 结构体内存对齐
现在大家应该都已经掌握了结构体的基本使用了，现在我们深入讨论一个问题：计算结构体的大小。这也是一个特别热门的考点： 结构体内存对齐
在正式讲解内存对齐之前，先用下面的代码来引入。你觉得答案是什么？
struct S1
{
char a;
char b;
int c;
};
struct S2
{
char a;
int c;
char b;
};
int main()
{
printf("%d\n", sizeof(struct S1));
printf("%d\n", sizeof(struct S2));
return 0;
}
你可以看见，答案居然不一样，可是两个结构体的成员是一样的呀，只是三个成员变量的顺序不同罢了。那我们现在就用可以计算结构体成员相较于起始位置的偏移量的宏offsetof
offserof括号里面的第一个参数是结构体类型，第二个是结构体成员。头文件：<stddef.h>
#include<stdio.h>
#include<stddef.h>
struct S1
{
char c1;
char c2;
int i;
};
struct S2
{
char c1;
int i;
char c2;
};
int main()
{
printf("%d ", offsetof(struct S1, c1));
printf("%d ", offsetof(struct S1, c2));
printf("%d\n", offsetof(struct S1, i));
printf("%d ", offsetof(struct S2, c1));
printf("%d ", offsetof(struct S2, i));
printf("%d\n", offsetof(struct S2, c2));
return 0;
}
我们发现，三个成员变量的顺序不同时，它们中的相同位置的相较于起始位置的偏移量不同，为什么呢？让我们来了解一下结构体的内存对齐
如何计算？
首先得掌握结构体的对齐规则
- 第一个成员在与结构体变量偏移量为0的地址处。
- 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
○VS中默认的值为8
○Linux环境中gcc这个编译器没有默认对齐数，对齐数就是成员自身的大小 - 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
- 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整
体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
下面我用的是VS
范例1：
创建一个类型为struct S1的变量s1，开辟空间时假如是从下图中的0开始的(下图中每个格子代表一个字节)， 第一个成员在与结构体变量偏移量为0的地址处，大小是1byte，只占1个字节。第二个成员是char类型的，大小是1byte，VS默认对齐数是8，8>1，所以对齐数是1，从地址是1的倍数开始占1个字节。第三个成员是int类型的，大小是4byte，VS默认对齐数是8，8>4，所以对齐数是4，从地址是4的倍数开始占4个字节。此时结构体占8个字节。结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍，第一个成员大小是1byte，8>1，所以对齐数是1，第二个成员对齐数是1，第三个成员对齐数是4，所以最大对齐数要是4的整数倍，8=4 * 2，可以，因此struct S1的大小为8byte。图中颜色块中间的白色部分是被浪费的内存
范例2：
创建一个类型为struct S2的变量s2，开辟空间时假如是从下图中的0开始的(下图中每个格子代表一个字节)， 第一个成员在与结构体变量偏移量为0的地址处，大小是1byte，只占1个字节。第二个成员是int类型的，大小是4byte，VS默认对齐数是8，8>4，所以对齐数是4，从地址是4的倍数开始占4个字节。第三个成员是char类型的，大小是1byte，VS默认对齐数是8，8>1，所以对齐数是1，从地址是1的倍数开始占1个字节。此时结构体占9个字节。结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍，第一个成员大小是1byte，8>1，所以对齐数是1，第二个成员对齐数是4，第三个成员对齐数是1，所以最大对齐数要是4的整数倍，9！=4 * 2，不行。12=4 * 3，可以，因此struct S2的大小为12byte
范例3：
struct S3
{
double d;
char c;
int i;
};
int main()
{
printf("%d\n", sizeof(struct S3));
return 0;
}
创建一个类型为struct S3的变量s3，开辟空间时假如是从下图中的0开始的(下图中每个格子代表一个字节)， 第一个成员在与结构体变量偏移量为0的地址处，大小是8byte，占8个字节。第二个成员是char类型的，大小是1byte，VS默认对齐数是8，8>1，所以对齐数是1，从地址是1的倍数开始占1个字节。第三个成员是int类型的，大小是4byte，VS默认对齐数是8，8>4，所以对齐数是4，从地址是4的倍数开始占4个字节。此时结构体占16个字节。结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍，第一个成员大小是8byte，8==8，所以对齐数是8，第二个成员对齐数是1，第三个成员对齐数是4，所以最大对齐数要是8的整数倍，16=8 * 2，可以，因此struct S3的大小为16byte
范例4：
struct S3
{
double d;
char c;
int i;
};
struct S4
{
char c1;
struct S3 s3;
double d;
};
int main()
{
printf("%d\n", sizeof(struct S4));
return 0;
}
创建一个类型为struct S4的变量s4，开辟空间时假如是从下图中的0开始的(下图中每个格子代表一个字节)， 第一个成员在与结构体变量偏移量为0的地址处，大小是1byte，占1个字节。第二个成员是结构体类型的，嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处即8的倍数处，大小是16byte。第三个成员是double类型的，大小是8byte，VS默认对齐数是8，8 ==8，所以对齐数是8，从地址是8的倍数开始占8个字节。此时结构体占32个字节。结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍，第一个成员大小是1byte，8 >1，所以对齐数是1，第二个成员对齐数是8，第三个成员对齐数是8，所以最大对齐数要是8的整数倍，32=8 * 4，可以，因此struct S4的大小为32byte
为什么存在内存对齐?
大部分的参考资料都是如是说的：
- 平台原因(移植原因)：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特
定类型的数据，否则抛出硬件异常 - 性能原因：
数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问
总体来说：
结构体的内存对齐是拿空间来换取时间的做法。
那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到：
让占用空间小的成员尽量集中在一起
例如：将第一段代码写成第二段代码
struct S1
{
char c1;
int i;
char c2;
};
struct S2
{
char c1;
char c2;
int i;
};
1.2 修改默认对齐数
我们可以使用#pragma 这个预处理指令来改变默认对齐数
#pragma pack(4)//设置默认对齐数为4
struct S1
{
char c1;
int i;
char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认
#pragma pack(2)//设置默认对齐数为2
struct S2
{
char c1;
int i;
char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认
int main()
{
//输出的结果是什么？
printf("%d\n", sizeof(struct S1));
printf("%d\n", sizeof(struct S2));
return 0;
}
1.3 结构体传参
直接上代码，请问下面的 print1 和 print2 函数哪个好些？
struct S
{
int data[1000];
int num;
};
struct S s = { {1,2,3,4}, 1000 };
//结构体传参
void print1(struct S s)
{
printf("%d\n", s.num);
}
//结构体地址传参
void print2(struct S* ps)
{
printf("%d\n", ps->num);
}
int main()
{
print1(s); //传结构体
print2(&s); //传地址
return 0;
}
答案：print2函数。
原因：函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。也可以这样想，传值调用的形参是实参的一份临时拷贝，开辟一个临时空间需要空间，而且拷贝也需要时间，因此传值调用的效率不高，所以尽量使用传址调用
那也有人要说了，print1比print2要安全呀，因为如果print1函数修改了形参的值的话，实参的结构体并不会被修改。但是如果print2函数修改了值，那么实参的结构体很轻易地被修改。是的，所以我们可以在形参struct S* ps前加const来保证ps指向的内容不会被修改
二. 位段
2.1 什么是位段
位段的声明和结构是类似的，有两个不同：
1.位段的成员必须是 int、unsigned int 或signed int 。(在C99之后，也可以是其它类型，但是基本上都是int，char)
2.位段的成员名后边有一个冒号和一个数字
比如：
struct A
{
int _a : 2;//_a占用2个bit的空间
int _b : 5;//_b占用5个bit的空间
int _c : 10;//……
int _d : 30;
};
A就是一个位段类型。那位段A的大小是多少
printf("%d\n", sizeof(struct A));
2.2 位段的内存分配
- 位段的成员可以是 int 、unsigned int、 signed int 或者是 char （属于整形家族）类型
- 位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的方式来开辟的。
- 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段
以下代码空间是如何开辟的？
typedef struct
{
unsigned char a : 4;
unsigned char b : 2;
unsigned char c;
unsigned char d : 1;
}pp;
int main()
{
printf("%d", sizeof(pp));
return 0;
}
因为a是unsigned char类型的，所以空间上是按照1个字节（ char ）的方式来开辟的，一个字节有8个bit，a占用4个，还剩4个；b是unsigned char类型的，占用2bit<4bit，所以可以与a共用一个字节，此时该字节还剩下2bit；c是unsigned char类型的，c没有说占用几个bit，默认占用1字节，上面的字节只剩下2bit，不够，所以需要重新开辟一个字节；d是unsigned char类型的，占用1bit，因为上一个字节（即c占用的）全被占用，所以要重新开辟一个字节，c占用1bit，还剩7bit。所以该位段共占用3个字节
2.3 位段的跨平台问题
- int 位段被当成有符号数还是无符号数是不确定的。
- 位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机器会出问题。
- 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
- 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的
总结：
跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在
三. 枚举
枚举顾名思义就是把可能的取值一一列举。比如我们现实生活中：一周的星期一到星期日是有限的7天，可以一一列举，性别有：男、女、保密，也可以一一列举，月份有12个月，也可以一一列举
3.1 枚举类型的定义
enum Gender
{
MALE,
FEMALE,
SECRET
};
enum Day
{
MON,
TUES,
WED,
THUR,
FRI,
SAT,
SUN
};
以上定义的 enum Day ， enum Gender 都是枚举类型。{ }中的内容是枚举类型的可能取值，也叫枚举常量.
这些可能取值都是有值的，默认从0开始，一次递增1，当然在定义的时候也可以赋初值
范例1：
默认从0开始，一次递增1
enum Gender
{
MALE,
FEMALE,
SECRET
};
int main()
{
printf("%d\n", MALE);
printf("%d\n", FEMALE);
printf("%d\n", SECRET);
return 0;
}
范例2：
在定义的时候部分赋初值，后面的一次递增1
enum Gender
{
MALE = 3,
FEMALE,
SECRET
};
//下面的main函数和范例1一样，就不再写了
范例3：
在定义的时候全部赋初值
enum Gender
{
MALE = 3,
FEMALE = 7,
SECRET = 1
};
//下面的main函数和范例1一样，就不再写了
3.2 枚举的使用
只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。如果将整型赋给枚举变量，可能会报错
enum Gender
{
MALE,
FEMALE,
SECRET
};
int main()
{
enum Gender gender = FEMALE;
enum Gender gender1 = 2;//ok?
return 0;
}
3.3 枚举的优点
为什么使用枚举？我们可以使用 #define 定义常量，为什么非要使用枚举？
枚举的优点：
- 增加代码的可读性和可维护性
- 和#define定义的标识符比较枚举有类型检查，更加严谨。
- 防止了命名污染（封装）
- 便于调试
- 使用方便，一次可以定义多个常量
四. 联合（共用体）
4.1 联合类型的定义
联合也是一种特殊的自定义类型。这种类型定义的变量也包含一系列的成员，特征是这些成员共用同一块空间（所以联合也叫共用体）。比如：
//联合类型的声明
union Un
{
char c;
int i;
};
//联合变量的定义
union Un un;
//计算1个联合体变量的大小
printf("%d\n", sizeof(un));
4.2 联合的特点
联合的成员是共用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小（因为联合至少得有能力保存最大的那个成员）。下面输出语句的结果是一样的吗？
union Un
{
int i;
char c;
};
int main()
{
union Un un;
printf("%p\n", &un);
printf("%p\n", &(un.i));
printf("%p\n", &(un.c));
return 0;
}
它们的输出结果相同，证明了联合的成员是共用同一块内存空间的
注意：联合体在同一时间只能使用1个，否则可能会出现问题
4.3 联合的应用
面试题：判断当前计算机的大小端存储
我们可能会想到下面这种方法：创造一个整型变量a并赋值为1
所以我们只要判断整型变量a的第一个字节的内容是1还是0就可以判断是上面存储方式了。所以我们将a的地址取出，强制类型转化为char * 类型的，此时该地址就是第一个字节的地址，再对该地址解引用就能找到该地址指向的内容
int check()
{
int a = 1;
return *(char*)&a;
}
int main()
{
int ret = check();
if (ret == 1)
printf("小端存储");
else
printf("大端存储");
return 0;
}
其实，还有一种很巧妙的方法，用联合体
因为联合的成员是共用同一块内存空间的，所以un.c访问的就是un.i的第一个字节
int check()
{
union
{
char c;
int i;
}un;
un.i = 1;
return un.c;
}
int main()
{
int ret = check();
if (ret == 1)
printf("小端存储");
else
printf("大端存储");
return 0;
}
4.4 联合大小的计算
○联合的大小至少是最大成员的大小。
○当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍
范例1：
最大成员大小是5byte。我们在上面结构体内存对齐时说过，对齐数 = 编译器默认的一个对齐数与该成员大小的较小值，VS的默认对齐数是8，字符数组是一群字符类型的变量的集合，它们占1byte<8，所以char的对齐数是1。int的对齐数是4，所以最大对齐数是4，最大成员大小5不是4的整数倍，8 ==4 * 2，所以联合体的大小是8byte
union
{
char c[5];
int i;
}un;
int main()
{
printf("%d\n", sizeof(un));
return 0;
}
范例1：
最大成员大小是14byte。短整型数组是一群短整型类型的变量的集合，它们占2byte<8，所以short的对齐数是2。int的对齐数是4，所以最大对齐数是4，最大成员大小14不是4的整数倍，16 ==4 * 4，所以联合体的大小是16byte
union
{
short c[7];
int i;
}un;
int main()
{
printf("%d\n", sizeof(un));
return 0;
}
文章来源：https://www.toymoban.com/news/detail-719658.html
好了，那么本篇博客就到此结束了，如果你觉得本篇博客对你有些帮助，可以给个大大的赞👍吗，感谢看到这里，我们下篇博客见❤️文章来源地址https://www.toymoban.com/news/detail-719658.html
到了这里，关于【C语言】结构体+位段+枚举+联合(2)的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
