C语言自定义类型联合体与枚举超详解

文章目录

1. 联合体
- 1. 1 联合体类型的声明
- 1. 2 联合体的特点
- 1. 3 相同成员的结构体和联合体对比
- 1. 4 联合体大小的计算
- 1. 5 联合体的练习
2. 枚举
- 2. 1 枚举类型的声明
- 2. 2 枚举类型的优点
- 2. 3 枚举类型的使用
- 2. 4 枚举类型的实际使用

1. 联合体

1. 1 联合体类型的声明

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

#include <stdio.h>
//联合类型的声明
union Un
{
	char c;
	int i;
};
int main()
{
	//联合变量的定义
	union Un un = { 0 };
	//计算联合体变量的大小
	printf("%zd\n", sizeof(un)); 
	return 0;
}

输出结果：

1. 2 联合体的特点

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

来看两个代码领会一下：
代码一

#include <stdio.h>
//联合类型的声明
union Un
{
	char c;
	int i;
};
int main()
{
	//联合变量的定义
	union Un un = { 0 };
	// 下⾯输出的结果是⼀样的吗？
	printf("%p\n", &(un.i));
	printf("%p\n", &(un.c));
	printf("%p\n", &un);
	return 0;
}

这三个输出应该是一样的，因为联合体的特点是所有成员共用同一块内存空间，既然是同一块空间，那自然也是同一块地址了。

代码二

#include <stdio.h>
//联合类型的声明
union Un
{
	char c;
	int i;
};
int main()
{
	//联合变量的定义
	union Un un = { 0 };
	un.i = 0x11223344;
	un.c = 0x55;
	printf("%x\n", un.i);
	return 0;
}

我们知道 int 类型的数据在内存中是以字节为单位逆向存储的(详见：数据在内存中的存储)，那么如图所示：

显然，当修改 un.c 时，同时也会修改 un.i 的数据，所以 un.i 此时应该是：0x11223355。

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

我们再对比一下相同成员的结构体和联合体的内存布局情况。

struct S
{
	char c;
	int i;
};
struct S s = { 0 };

union Un
{
	char c;
	int i;
};
union Un un = { 0 };

如图所示：

1. 4 联合体大小的计算

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

来根据上面的规则计算一下：

#include <stdio.h>
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;
}

Un1：首先联合体要有能力存下 char c [5] 这个变量，所以联合体大小是5，然后我们再来算对齐数，我们在结构体的时候就说过：

对齐数 = 编译器默认的一个对齐数与该成员变量大小的最大值的较小值。
VS 中默认的值为 8
Linux中 gcc 没有默认对齐数，对齐数就是成员自身的大小

所以这个联合体的对齐数很好计算，是 4，那么 5 后面的第一个 4 的倍数是 8，因此这个联合体的大小就是 8。

Un2 ：short c[7] 是最大的成员,大小是14，联合体的对齐数是4，所以这个联合体的大小是16。

使用联合体是可以节省空间的，举例：
我们要搞一个活动，要上线一个礼品兑换单，礼品兑换单中有三种商品：图书、杯子、衬衫。
每一种商品都有：库存量、价格、商品类型和商品类型相关的其他信息。
商品相关的其他信息各不相同：
图书:书名、作者、页数
杯子:设计
衬衫:设计、可选颜色、可选尺寸
那我们可以不假思索地写出这个结构体：

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;//尺寸
};

上述的结构其实设计的很简单，用起来也方便，但是结构的设计中包含了所有礼品的各种属性，这样使得结构体的大小就会偏大，比较浪费内存。因为对于礼品兑换单中的商品来说，只有部分属性信息是常用的。比如:
商品是图书，就不需要design、colors、sizes。
所以我们就可以把公共属性单独写出来，剩余属于各种商品本身的属性使用联合体存储，这样就可以减少所需的内存空间，一定程度上节省了内存。

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. 5 联合体的练习

写一个程序，判断当前机器是大端还是小端。

实际上，这道题目我在数据存储这篇博客的2.3 中就已经讲解过，并且也使用了联合体求解，这里便不再赘述了。

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

2. 枚举

2. 1 枚举类型的声明

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

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

这些数据的表示就可以使用枚举了。

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

以上定义的 enum Day，enum Color ,enum Sex都是枚举类型。
{}中的内容是枚举类型的可能取值，也叫枚举常量。
这些可能取值都是有值的，默认从0开始，依次递增1，当然在声明枚举类型的时候也可以赋初值。
比如在enum Color中，如果不赋初值，默认是这样的：

enum Color//颜⾊
{
	RED = 0,
	GREEN = 1,
	BLUE = 2
};

但是也可以进行赋初值：

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

除此之外，还可以对其中几项单独赋初值，比如：

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

那么这个时候这三个枚举常量分别是多少呢？
实际上，如果是这样对某些常量赋初值的话，枚举类型的第一个常量仍然从0开始，依次递增1，直到遇见赋初值的常量，然后从这个赋了初始值的常量的值开始，再次依次递增1。
上面的枚举常量的值分别是：

enum Color//颜色
{
	RED = 0,
	GREEN = 4,
	BLUE = 5
};

2. 2 枚举类型的优点

为什么使用枚举?

我们可以使用 #define 定义常量，为什么非要使用枚举?
枚举的优点:

增加代码的可读性和可维护性
和#define定义的标识符相比枚举有类型检查，更加严谨。
便于调试，预处理阶段会删除 #define 定义的符号
使用方便，一次可以定义多个常量
枚举常量是遵循作用域规则的，枚举声明在函数内，只能在函数内使用

总而言之，枚举相较于 #define 定义的常量使用起来更加严谨，方便，因此一般情况下更推荐使用枚举。

2. 3 枚举类型的使用

枚举常量再其定义域内是可以和 #define 定义的常量一样直接使用的，除此之外，枚举还有枚举变量，可以和其他类型的变量一样进行赋值等操作：

#include<stdio.h>

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

int main()
{
	enum Color clr = GREEN;//使用枚举常量给枚举变量赋值
	enum Color clr2 = 2;//这样在C语言中是可以的，但在C++中，由于更严格的检查，这样是不行的
	enum Color clr3 = 3;//使用 int 类型给枚举类型赋值可能会出现这样的情况，
						//3并不是某个枚举常量的值，但并不会报错
	printf("%d ", clr3);

	return 0;
}

甚至还能将3打印出来，这显然不是我们使用枚举预期的结果，因此要避免这样赋值。

2. 4 枚举类型的实际使用

说了这么多，我们来试一下枚举类型实际上该怎么使用吧，在之前的博客中，我们写过很多次计算器，这是我们在指针中使用回调函数优化的计算器：

回调函数
但是你有没有想过一个问题：在 main 函数的 switch 中，为什么 case1 就是加法，而case2 就是减法？当然这是和菜单一一对应的，但这显然并不利于代码的可阅读性，如果这是一个非常复杂的项目，这样的代码是很难理解的，那么我们可以使用枚举来优化这个代码的可阅读性：

//使用回到函数改造后，再使用枚举提高代码可阅读性
#include <stdio.h>
int add(int a, int b)
{
	return a + b;
}
int sub(int a, int b)
{
	return a - b;
}
int mul(int a, int b)
{
	return a * b;
}
int div(int a, int b)
{
	return a / b;
}

enum calc_num	//这里设置一个枚举类型，注意顺序，或者可以赋初值，要和菜单中的数字保持一致
{
	END,
	ADD,
	SUB,
	MUL,
	DIV
};

void calc(int(*pf)(int, int))//看一看这个函数，它的参数是一个函数指针，而且这个函数指针的		
{							 //类型恰好和上面的4个计算用的函数类型相同
	int ret = 0;
	int x, y;
	printf("输入操作数：");
	scanf("%d %d", &x, &y);
	ret = pf(x, y);	//调用 calc 函数，会调用传参过来的函数，这就是回调函数
	printf("ret = %d\n", ret);
}
int main()
{
	int input = 1;
	do
	{
		printf("*************************\n");
		printf("	1:add 2:sub \n");
		printf("	3:mul 4:div \n");
		printf("*************************\n");
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case ADD://将case后的值都替换成枚举常量
			calc(add);//这里调用 calc 函数实际上是是在通过 calc 函数调用其他的函数
			break;
		case SUB:
			calc(sub);
			break;
		case MUL:
			calc(mul);
			break;
		case DIV:
			calc(div);
			break;
		case END: printf("退出程序\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);
	return 0;
}