自定义类型：结构体，枚举，联合 (2)

2. 位段

位段的出现就是为了节省空间。

2.1 什么是位段

位段的声明和结构是类似的，有两个不同：
1.位段的成员必须是 int、unsigned int 或signed int 。
2.位段的成员名后边有一个冒号和一个数字。

比如：

struct A
{
   int _a:2;
   int _b:5;
   int _c:10;
   int _d:30;
};

A就是一个位段类型，位段的位指的是二进制位，成员名后的数字代表着占空间的多少个bit位，_a占2个bit位，_b占5个bit位。
那位段A的大小是多少？

如果这个A是结构体的话，那就至少占16个字节，而如果是位段则是8个字节这是为什么呢？

struct A
{
	int _a : 2;
	int _b : 5;
	int _c : 10;
	int _d : 30;
};
int main()
{

    printf("%d\n", sizeof(struct A));
	return 0;
}

2.2 位段的内存分配

1. 位段的成员可以是 int unsigned int signed int 或者是 char （属于整形家族）类型
2. 位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的方式来开辟的。
3. 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。

我们使用上面的代码在空间预开辟一下，因为成员都是int，所以先开辟一个整型，4个字节，32个bit位，那么_a先占2个bit位，那么这32个bit位是从左向右使用还是从右向左使用呢？这个是不确定的，所以说位段是不跨平台的，不同的编译器可能有所差异。当我们使用了30个bit位，还剩下2个bit位，但是下一个成员需要使用6个bit位，那么剩下的这2个bit位用不用呢？不用的话就浪费了，用的话则还需要开辟4个bit位，这个也是不确定的。

即使有再多的不确定性，我们也可以探究一下在vs上，到底是怎么使用的。

这个结构体S类型中a占3个bit位，b占4个bit位，c占5个bit位，d占4个bit位，s创建好之后赋值为0，将a里面放个10，b里面放个12，c里面放个3，d里面放个4.接下来我们进行分析。

struct S
{
	char a : 3;
	char b : 4;
	char c : 5;
	char d : 4;
};
int main()
{
	struct S s = { 0 };
	s.a = 10;
	s.b = 12;
	s.c = 3;
	s.d = 4;
	return 0;
}

由于成员都是char类型，所以一次分配一个字节，你们先在内存中开辟一个字节，先开始存放a，a占了3个bit位，假设先使用低位，a则占用了3个bit位，然后b要占4个bit位，则再往左占用4个bit位，然后第一个字节还剩下一个bit位，存放c是不够用的，那么再次开辟一个字节，如果使用第一个字节中剩下的bit位，那么存放c和d只需要再使用一个字节，如果不使用则再需要开辟一个字节。

我们来测试一下，到底是怎样的。结果是3，那么就是浪费了这剩余的一个字节。

a只能使用3个bit位，所以只能将10的二进制的后三位存进去，就是010， b就是1100，c是00011，d是0100.如果换成16进制的话，就是6，2，0，3，0，4.

通过调试我们发现就是这样的情况，那么我们的猜测就是对的，内存是从低位到高位使用的，同时当剩余的空间不够下一个成员使用时，就直接浪费掉，开辟新的空间。

2.3 位段的跨平台问题

1. int 位段被当成有符号数还是无符号数是不确定的。
2. 位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机器会出问题。
3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。

总结：

跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。

2.4 位段的应用

当我们在传输数据的时候要对数据进行封装的，可能要在数据上包上一系列的数据，像上面这样。

面对上面这样的数据，使用位段就非常方便，刚好32位，可以节省空间。

当数据比较大，给网络的负担就比较大，当数据比较小，除了真正要传输的数据，其他的这些数据很小，给网络的负担就比较小，效率就比较高。

3. 枚举

枚举顾名思义就是一一列举
把可能的取值一一列举。
比如我们现实生活中：

一周的星期一到星期日是有限的7天，可以一一列举。
性别有：男、女、保密，也可以一一列举。
月份有12个月，也可以一一列举。

这里就可以使用枚举了。

3.1 枚举类型的定义

enum Day//星期
{
	Mon,
	Tues,
	Wed,
	Thur,
	Fri,
	Sat,
	Sun
};
enum Sex//性别
{
	MALE,
	FEMALE,
	SECRET
};
enum Color//颜色
{
	RED,
	GREEN,
	BLUE
};

以上定义的 enum Day ， enum Sex ， enum Color 都是枚举类型。
{}中的内容是枚举类型的可能取值，也叫枚举常量。
这些可能取值都是有值的，默认从0开始，一次递增1。

所以当我们想在主函数里面修改这个常量值是不行的，因为是常量。

当然在定义的时候也可以赋初值。例如：

enum Color//颜色
{
	RED = 1,
	GREEN = 2,
	BLUE = 4
};

3.2 枚举的优点

为什么使用枚举？

我们可以使用 #define 定义常量，为什么非要使用枚举？

枚举的优点：
1. 增加代码的可读性和可维护性
2. 和#define定义的标识符比较枚举有类型检查，更加严谨。
3. 防止了命名污染（封装）
4. 便于调试
5. 使用方便，一次可以定义多个常量

3.3 枚举的使用

虽然说枚举变量的值是不能被改的，但是枚举变量在最初始的时候是可以进行赋值的。

enum Color//颜色
{
  RED=1,
  GREEN=2,
  BLUE=4
};
enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。

那么枚举变量的所占内存大小是多少呢？

enum Sex//性别
{
	MALE,
	FEMALE,
	SECRET
};
int main()
{
	enum Sex sex = FEMALE;
	printf("%d\n", sizeof(sex));
	return 0;
}

其实枚举变量的大小就是一个整型的大小。

4. 联合（共用体）

4.1 联合类型的定义

联合也是一种特殊的自定义类型
这种类型定义的变量也包含一系列的成员，特征是这些成员公用同一块空间（所以联合也叫共用体）。
比如：

//联合类型的声明
union Un
{
	char c;
	int i;
};
//联合变量的定义
union Un un;

如果我们想计算一下联合体的大小，那么int4个字节，char1个字节，答案是不是这样的呢？

4.2 联合的特点

联合的成员是共用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小（因为联合至少得有能力保存最大的那个成员）。

如果我们想计算一下联合体的大小，那么int4个字节，char1个字节，答案是不是这样的呢？

union Un
{
	char c;
	int i;
};
int main()
{
	union Un un;//联合变量的定义
	printf("%d\n", sizeof(union Un));
	return 0;
}

这是为什么呢？

当我们将un和它的成员地址打印出来，发现地址是一样的。

union Un
{
	char c;
	int i;
};
int main()
{
	union Un un;//联合变量的定义
	printf("%p\n", &un);
	printf("%p\n", &(un.c));
	printf("%p\n", &(un.i));
	return 0;
}

i占4个字节，c占一个字节，并且地址是一样的，那么i的第一个字节和c的第一个字节是不是同一块空间呢？也就是共用一块空间？

答案是对的，所以联合体也叫共用体。但是会互相影响，改变一个其他的也会改变。

所以联合体的大小至少是最大成员的大小，才有能力保存数据。

那么联合体有什么用呢？

联合体可以用来判断当前机器是大端还是小端。当数据的低位数据放在内存的低地址处就叫做小端存储，当数据的低位数据放在内存的高地址处就叫做大端存储。

之前写过一个判断代码如下：

int check_sys()
{
	int a = 1;
	if (*(char*)&a == 1)
		return 1;
	else
		return 0;
}
int main()
{
	int ret = check_sys();
	if (ret == 1)
		printf("小端\n");
	else
		printf("大端\n");

	return 0;
}

简化后如下：

int check_sys()
{
	int a = 1;
	return *(char*)&a;//返回1表示小端，返回0表示大端
}
int main()
{
	int ret = check_sys();
	if (ret == 1)
		printf("小端\n");
	else
		printf("大端\n");

	return 0;
}

现在我们使用联合体来判断：

首先我们创建一个联合体变量u，当我们给i赋值1，那么拿c的值就是拿i的第一个字节的数据，那么return c就可以得到结果。

int check_sys()
{
	union
	{
		char c;
		int i;
	}u;
	u.i = 1;
	return u.c;//返回1表示小端，返回0表示大端
}

int main()
{
	int ret = check_sys();
	if (ret == 1)
		printf("小端\n");
	else
		printf("大端\n");
	return 0;
}

4.3 联合大小的计算

联合的大小至少是最大成员的大小。
当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。

比如：

Un1中c是5个字节，i是4个字节，为什么Un1却是8个字节呢？当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。c是个数组，最大对齐数是按元素算的，相当于放了5个char类型的变量，那么最大对齐数就是1，i的最大对齐数是4，那么就要浪费掉3个字节，就是8.

Un2中c是7个字节，i是4个字节，那为什么Un2是16个字节呢？c是short类型的数组，最大对齐数是2，i的最大对齐数是4，但是c占14个字节，那么就是16.

union Un1
{
	char c[5];
	int i;
};
union Un2
{
	short c[7];
	int i;
};
int main()
{
	printf("%zd\n", sizeof(union Un1));
	printf("%zd\n", sizeof(union Un2));
	return 0;
}