联合体&枚举

目录

一. 联合体/共用体  

1. 联合体类型的声明

2.联合体的特点

3.相同成员的结构体和联合体对比

4.联合体大小的计算

5.联合体应用的场景

6.联合的2个练习

2. 枚举类型

1.枚举类型的声明

2.枚举类型的优点

---

一. 联合体/共用体  

1. 联合体类型的声明

像结构体，跟结构体非常相似，联合体也是有一个或者多个成员构成，这些成员可以不同类型。
但是/*编译器只为最大的成员分配足够的内存空间*/。联合体的/*特点是所有成员公用同一块内存空间*/。所以联合体也叫：共用体。
联合体的关键字：union
特性：给联合体其中⼀个成员赋值，其他成员的值也跟着变化。

代码举例：探究联合体和结构体区别

struct S//结构体声明
{
	char c;
	int u;
//会先给c开辟空间，浪费3个字节，再给u开辟空间。
//每个成员都要存放数据，都有自己独立的空间。
};

union U //联合体声明
{
	char c;//1
	int u;//4 - c和u都要占空间至少是5个字节，为啥是4个字节
};
int main()
{
	union U uu; 
	printf("%zd\n", sizeof(uu));//4 - 联合体大小至少是联合体成员最大的值。
	printf("%p\n", &uu);//00AFF974
	printf("%p\n", &(uu.c));//00AFF974
	printf("%p\n", &(uu.u));//00AFF974
//发现3个地址都一样，所以联合成员公用同一块空间，所以联合体也叫共用体。
//当我使用c，u就改了或当我使用u，c也改了，这2个成员不会同时使用，这样才会共存。

	return 0;
}

感觉只是关键字的区别，但是本质上也是有区别的。

2.联合体的特点

1.联合的成员是共⽤同⼀块内存空间的，这样⼀个联合变量的大小，⾄少是最⼤成员的大小（因为联合⾄少得有能⼒保存最⼤的那个成员）。
2.当我们改变联合体成员其中一个值的时候，另一个成员也会跟着改变，这2个成员不会共同用。

代码举例：再次探究联合体公用同一块空间

union Un
{
	char c;
	int i;
};
int main()
{
	union Un un = { 0 };
	un.i = 0x11223344;
	un.c = 0x55;
	printf("%x\n", un.i);//11223355
//发现将i的第4个字节的内容修改为55了。
//当我们使用i的时候，c就不能用，c拿到的其中的一个值，当你改c的时候i的值也跟着改了。

	return  0;
}

3.相同成员的结构体和联合体对比

再对比⼀下相同成员的结构体和联合体的内存布局情况。
1.结构体：每个成员存放数据都会有独立的空间，为了追求效率其中可能会浪费空间。
2.联合体：每个成员公用同一块空间，使用其中一个成员就不能使用另一个成员，修改一个成员，所有成员都会都会改变。

4.联合体大小的计算

• 联合的⼤⼩⾄少是最⼤成员的⼤小。/*不是一定是最大成员的大小*/。
• 当最⼤成员大小不是最⼤对⻬数的整数倍的时候，就要对⻬到最⼤对⻬数的整数倍。联合体也存在对齐。

代码举例：1.计算联合体大小

union Un1
{
	char c[5];//对齐数：1 8 1
	int i;//对齐数：4 8 4
	//5 < 最大对齐数的整数倍数,所以要对齐，要浪费3个字节，所以是 8
};
union Un2
{
	short c[7];//对齐数：2 8 2
	int i;//对齐数：4 8 4 
	//14 < 最大对齐数的整数倍数，所以要对齐到，药浪费2个字节，所以是16
};
int main()
{
	printf("%zd\n", sizeof(union Un1));//8
	printf("%zd\n", sizeof(union Un2));//16

	return 0;
}

补充：数组计算对齐数是按元素来算对齐数。
总结：联合体看似是节省空间的，但是也是存在对齐的。

5.联合体应用的场景

使⽤联合体是可以节省空间的，举例：
⽐如，我们要搞⼀个活动，要上线⼀个礼品兑换单，礼品兑换单中有三种商品：图书、杯⼦、衬衫。
每⼀种商品都有：库存量、价格、商品类型和商品类型相关的其他信息。
图书：书名、作者、⻚数
杯⼦：设计
衬衫：设计、可选颜⾊、可选尺⼨

代码举例：直接用结构体设计

struct gift_list
{
	//公共属性
	int stock_number;//库存量
	double price; //定价
	int item_type;//商品类型

	//个性属性
	char title[20];//书名
	char author[20];//作者
	int num_pages;//⻚数

	char design[30];//设计
	int colors;//颜⾊
	int sizes;//尺⼨
};
int main()
{
	return 0;
}

问题：全部属性全部干到整个结构体
1.上述的结构其实设计的很简单，⽤起来也⽅便，但是结构的设计中包含了所有礼品的各种属性,这样使得结构体的大小就会偏⼤，比较浪费内存。因为对于礼品兑换单中的商品来说，只有部分属性信息是常⽤的。
2.比如：当我们用这个结构体类型描述图书的时候会发现设计，颜色，尺寸用不上浪费了空间。

解决问题：
1.用联合体解决
2.可以把公共属性单独写出来，剩余属于各种商品本⾝的属性使⽤联合体起来，这样就可以介绍所需的内存空间，⼀定程度上节省了内存。

代码举例：结构体和联合嵌套使用

代码举例：结构体和联合嵌套使用
struct gift_list
{
	//公共属性
	int stock_number;//库存量
	double price; //定价
	int item_type;//商品类型

	//个性属性
	union // - 匿名联合体
	{ 
		struct // - 匿名结构体  - 描述书的结构体
		{
			char title[20];//书名
			char author[20];//作者
			int num_pages;//⻚数
		}book;
		struct// - 匿名结构体  - 描述杯子的结构体
		{
			char design[30];//设计
		}mug;
		struct// - 匿名结构体  - 描述衬衫的结构体
		{
			char design[30];//设计
			int colors;//颜⾊
			int sizes;//尺⼨
		}shirt;
	}item;
};
//1.联合体的成员是3个结构体：book，mug和item公用同一块空间，不会同时存在，根据最大的成员开辟空间
//2.联合体和联合体成员里面结构体都是匿名，因为只使用一次。直接定义的他们变量。
int main()
{
	return 0;
}

总结：里面的个性属性信息不会全部存起来，一定程度节省了空间，这就是好的设计。

6.联合的2个练习

代码举例1：取出整形每个字节数据

union U
{
	int n;//4
	struct S
	{
		char c1;
		char c2;
		char c3;
		char c4;
	}s;//4
};
int main()
{
	union U u = { 0 };
	u.n = 0x11223344;
	printf("%x %x %x %x\n", u.s.c1, u.s.c2, u.s.c3, u.s.c4);//小端 44 33 22 11
	printf("%x %x %x %x\n", u.s.c4, u.s.c3, u.s.c2, u.s.c1);//大端 11 22 33 44

	return 0;
}

分析：联合体里面的成员共用同一块空间，当改变一个成员值的时候，另一个成员也要跟着改变。

代码举例2：判断当前机器是大端还是小端

int fufu_sys()
{
	union
	{
		char c;
		int i;
	}u;
	u.i = 1;
	return u.c;
}
int main()
{
	int ret = fufu_sys();
	if (ret == 1)
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}

	return 0;
}

分析：
1.因为这是联合体i 和 c共用同一块空间，当你改变i的值c的值也要发生变化。
2.因为c是char类型，当你取c的值就相当于取出整形i第一个字节的值。
 

2. 枚举类型

1.枚举类型的声明

枚举顾名思义就是⼀⼀列举。
把可能的取值⼀⼀列举。
枚举的关键字 - enum

比如我们现实⽣活中：
⼀周的星期⼀到星期⽇是有限的7天，可以⼀⼀列举
性别有：男、⼥、保密，也可以⼀⼀列举
⽉份有12个⽉，也可以⼀⼀列举
三原⾊，也是可以一一列举
这些数据的表⽰就可以使⽤枚举了。
但是生活中有些值没有办法被一一列举，比如：身高，体重，工资要是一一列举会很多。

代码举例：使用枚举一一列举

enum Sex
{
//这里列举枚举enmu Sex的可能取值
//这些可能取值是常量，也叫枚举常量，是不能被修改的，但是即使是常量也可以自己初始一个值，但不能被修改。
//默认值从0开始，以此内推，

	//初始值
	//MALE,//0
	//FEMALE,//1
	//SECRET,//2

	//MALE = 5,//5
	//FEMALE,//6
	//SECRET,//7

	MALE = 5,//5
	FEMALE = 8,//8
	SECRET = 10,//10
};
int main()
{
	printf("%d\n", MALE);//0
	printf("%d\n", FEMALE);//1
	printf("%d\n", SECRET);//2

	//MALE = 20；当你去修改，不能修改。

	//枚举类型的使用
	enum Sex s = MALE;//MALE初始值是5，但是不能在枚举变量写5，但编译能过，因为c语言不严谨，换c++会报错。
//报的错误是：5是int类型，s是enum Sex类型，编译器认为2边类型不一样。
	s = FEMALE;

	return 0;
}

枚举变量的值不能写其它类型！只能写枚举常量的值！否则会报错！

总结：枚举类型的变量，只能用枚举常量的值/也叫枚举可能取值。

2.枚举类型的优点

为什么使⽤枚举？
我们可以使⽤ #define 定义常量，为什么非要使⽤枚举？//对比
比如:#define MAX 10 为啥要用枚举？

枚举的优点：
1. 增加代码的可读性和可维护性。
2. 和#define定义的标识符比较枚举有类型检查，更加严谨。//因为#define定义的符号是没有类型的，枚举定义的成员是有枚举类型的。
3. 便于调试，预处理阶段会删除 #define 定义的符号。//枚举类型创建的变量是可以调试的，#define定义的的符号不便于调试，会替换文本。
4. 使⽤⽅便，⼀次可以定义多个常量。
5. 枚举常量是遵循作⽤域规则的，枚举声明在函数内，只能在函数内使⽤。

总结：
1.能用枚举去写的，少用#define定义的符号。
2.#define定义的符号，不方便调试。
3.枚举定义常量只用逗号隔开就可以了，#define定义的常量，要使用3次#define。
4.#define定义的符号是全局范围，没有作用域范围概念。

技巧：做题思想
1.对于十进制操作脑子第一个想到的是/10 和 % 10
2.对于二进制拆分脑子想到的是/2 和 %2
3.把要删除的值覆盖掉思想