C语言（通识）_对结构体、枚举、联合的知识讲解

---

结构体

结构体的内存对齐

内存对齐，是结构体在计算大小的时所发生的。对齐方式是有规则的，我们来看看官方说法：

1. 第一个成员在与结构体变量偏移量为0的地址处。
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
   对齐数 = 编译器默认的一个对齐数与该成员大小的较小值。（VS默认值为8、Linux没有默认值）
3. 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

看了觉得一头雾水？偏移量、对齐数、默认值这都是什么鬼？
别着急，我们接下来一步步解读。先看一个小例子：

#include <stdio.h>
struct U
{
	char a;
	int b;
	char c;
};

int main()
{
	struct U u;
	printf("%d\n", sizeof(u));
	return 0;
}

打印结果为12。也许你要开始疑惑了，char为1个字节，int类4个字节，1+4+1=6，怎么就是12了呢？
如果是按照结构体大小为6字节来理解（如图）：

很显然，现实并非这么简单。先解释偏移量：红色箭头所指开辟空间的地方，偏移量为0，接下来每跳过一个字节，偏移量加1。
知道了偏移量，我们使用offsetof函数（记得添加头文件<stddef.h>），它可以告知我们结构成员相对起始位置的偏移量

#include <stdio.h>
#include <stddef.h>
struct U
{
	char a;
	int b;
	char c;
};

int main()
{
	struct U u;
	printf("%d\n", offsetof(struct U,a));
	printf("%d\n", offsetof(struct U, b));
	printf("%d\n", offsetof(struct U, c));
	return 0;
}

打印结果为0、4、8。按照打印结果可以得到下图：

结合看规则的第二句：“对齐到某个数（对齐数）的整数倍的地址处。”char a放进内存之后，int b是4个字节，4和8相比，4为较小值，所以此时对齐数为4，int b要在4的整数倍开始放，需要跳过3个字节，所以int b的偏移量为4，int b 占用之后，char c 放在偏移量为8处。
0~8有9个字节，再看第三句：“结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍”。struct U的每个成员对齐数分别为1、4、1，最大显然为4，因为9还不是4的倍数，所以需要补齐至12，一开始的12就是这么来的。
一共只有6个字节的数据却占用了12个字节，是不是觉得太浪费了，所以通常情况下会把比较小的成员放在前面，大的堆在后面。就像是一条队列，矮的站前面，高的往后站。

内存对齐的意义

合理安排位置后只浪费了2个字节。好奇的小伙伴就会问，既然总会有浪费，那么究竟意义何在呢？

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

说白了空间和时间如同鱼和熊掌的关系。空间我所欲也，时间亦我所欲也，二者不可得兼，舍空间而取时间也。

对齐数的自定义

VS默认对齐数为8，你也可以自行修改默认值

---

结构体传参

下面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;
}

答案：第二个好。理由如下：当我们把s传入print1时，形参s是实参S的一份临时拷贝，如果实参S比较大，那么形参s也会大，空间上会有很大的浪费，而且数据再拷过去也需要时间，鱼翅、熊掌都丢了。不过如果使用print2，传地址，无非就是4（32位机器）或者8（64位机器）个字节，这样传参的效果更好，效率更高。

---

位段型结构体

有没有没听说过位段的兄弟？有的话举一下手我看看有多少。位段的声明和结构类似，不过只有两个不同，1. 位段成员有：int 、signed int 、unsigned int 、char ; 2. 位段成员后面有冒号和数字。光说没用，直接看怎么写的吧：

struct A
{
	int a : 2;
	unsigned int b : 4;
	signed int c : 10;
	int d : 30;
};
int main()
{
	printf("%d\n", sizeof(struct A));
	return 0;
}

位段A有多大，冒号后的数字是什么意思呢？我们来猜测一下结构体A有几个字节。有人一眼扫过去2+4+10+30，46简直是脱口而出。哈哈哈，如果是这么简单的问题，我还会问你吗？这里就不卖关子了，打印结果为8。8怎么来的呢，听我给您慢慢道来。
位段的位，指的是二进制位，如果没有冒号，int a 是占4个字节，即32个比特位，加上 “ ：2 ”，int a 只占2个比特位，故冒号后的数字表示占的比特位，而不是字节。位段有什么用处呢？现实中我们遇到的情况是有限的，和四个字节（2的32次方）相比简直是九牛一毛、沧海一粟。就比如表示性别：男、女、秘密；只有2种可能 ，那么两个比特位就足够了。位段的出现是为了在一定程度上节省空间。善于使用位段的人就好如空间管理大师，把行李箱利用到：再多一件衣服都塞不进去。位段就这么神。特别提醒：位段后面的数字不能超过32，一个 int 最多就是32，再高就超出 int 能力范围了，切忌不可为所欲为，冒号后面来一个36、40，int 只好说臣妾做不到，编辑器也会报错。

---

位段的内存分配

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

按照规则遇到 int 开辟4字节（ 32bit )，32bit分配 int a 2 bit 剩余30bit ；unsigned int b 分配4个，剩余26bit；signed int c 分配10，剩余16；int d需要30bit，16不够，再开辟32bit。所以上文打印的8字节（64bit)，由此而来。在空间上的利用，位段和结构体相比，显得更加精细化。

位段的缺陷

细心的小伙伴会之前有一点没有说清楚，那就是一开始开辟的四个字节，剩余的比特位是直接浪费了还是继续利用的？这个C语言标准没有规定，不同的编译器处理方式也不同，所以位段的移植性比较差，不适合跨平台。

不仅如此，当在位段放入int 和char 是，是被当成有符号还是无符号，不确定，即最高位是符号位还是有效位 不确定。

在不同机器中，位段的最大位的数目不确定：16位机器是16，32位机器是32，所以在32位机器合理的30，在16位机器就无法运行。

---

枚举

枚举，通俗地说就是一一列举，生活中的星期、月份、颜色都可以通过枚举展示。
来看一下枚举语法规则：

enum Sex
{
	//枚举的可能取值
	MALE,
	FEMALE,
	SECRET
};

int main()
{
	enum Sex s = MALE;
	return 0;
}

---

枚举类型的定义

其中枚举类型是有值的，我们来看一下打印结果：

可以看出默认从0开始，之后每一个递增1。内部的值也可以自行修改，直接看效果：

---

枚举的优点

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

通过下面这个计算器的实现就可以看出不同：
1.没有使用枚举的版本

void menu()
{
	printf("*******************************\n");
	printf("***** 1.add       2.sub   *****\n");
	printf("***** 3.mul       4.div   *****\n");
	printf("******0.exit              *****\n");
	printf("*******************************\n");

}

void menu2()
{
	printf("请输入两个数:>");
}

int ADD(int x,int y)
{
	return x + y;
}

int SUB(int x, int y)
{
	return x - y;
}

int MUL(int x, int y)
{
	return x * y;
}

int DIV(int x, int y)
{
	return x / y;
}

int main()
{
	int intput = 0;
	int x = 0;
	int y = 0;
	int z = 0;
	do
	{
		menu();
		printf("choose:>");
		scanf("%d", &intput);
		menu2();
		switch (intput)
		{
		case 1:
			scanf("%d%d", &x, &y);
			z = ADD(x, y);
			break;
		case 2:
			scanf("%d%d", &x, &y);
			z = SUB(x, y);
			break;
		case 3:
			scanf("%d%d", &x, &y);
			z = MUL(x, y);
			break;
		case 4:
			scanf("%d%d", &x, &y);
			z = DIV(x, y);
			break;
		case 0:
			printf("退出程序。\n");
			break;
		default:
			printf("输入错误，请重新输入！\n");
			break;
		}
		printf("%d\n", z);
	} while (intput);
	return 0;
}

2.使用了枚举的版本

enum Choice
{
	exit,
	add,
	sub,
	mul,
	div
};

void menu()
{
	printf("*******************************\n");
	printf("***** 1.add       2.sub   *****\n");
	printf("***** 3.mul       4.div   *****\n");
	printf("******0.exit              *****\n");
	printf("*******************************\n");

}

void menu2()
{
	printf("请输入两个数:>");
}

int ADD(int x,int y)
{
	return x + y;
}

int SUB(int x, int y)
{
	return x - y;
}

int MUL(int x, int y)
{
	return x * y;
}

int DIV(int x, int y)
{
	return x / y;
}

int main()
{
	int intput = 0;
	int x = 0;
	int y = 0;
	int z = 0;
	do
	{
		menu();
		printf("choose:>");
		scanf("%d", &intput);
		menu2();
		switch (intput)
		{
		case add:
			scanf("%d%d", &x, &y);
			z = ADD(x, y);
			break;
		case sub:
			scanf("%d%d", &x, &y);
			z = SUB(x, y);
			break;
		case mul:
			scanf("%d%d", &x, &y);
			z = MUL(x, y);
			break;
		case div:
			scanf("%d%d", &x, &y);
			z = DIV(x, y);
			break;
		case exit:
			printf("退出程序。\n");
			break;
		default:
			printf("输入错误，请重新输入！\n");
			break;
		}
		printf("%d\n", z);
	} while (intput);
	return 0;
}

通过对比，就可以发现，添加了enum Choice，switch语句中就不再是case1、case 2这样的表达，并且如果想添加新的运算符号如%、&、|、^等，就不会混乱，代码可维护性、可读性更高了。

---

联合

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

union Aa
{
	char c;
	int i;
};

int main()
{
	union Aa a;
	printf("%d\n", sizeof(a));
	return 0;
}

打印结果是4个字节，为什么不是4+1=5个字节呢？因为这是联合体，通过取地址来看一下 c 和 i 的位置：
都是在同一个位置，说明 i 和 c 共用同一块空间。看出联合体的大小最少是最大成员的大小，内存大小后文会提及。

---

联合体的使用

直接实战：
通过联合体来判断大小端

#include <stdio.h>
int check()
{
	union A
	{
		char c;
		int i;
	}A;
	A.i = 1;
	return A.c;
}

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

因为如果i放1进去，小端4个字节放置的就是01 00 00 00，大端就是00 00 00 01。故小端 c 放的就是01，大端 c 放置00。利用的就是联合体中 i 和 c 公用的同一块空间这个特点。

---

联合体的内存大小

规则：
1.联合体的大小最少是最大成员的大小
2.当最大成员的大小不是最大对齐数的整数倍时，要对齐到最大对齐数的整数倍。

看实例

union A
{
	char c[7];
	int i;
};



int main()
{
	union A a;
	printf("%d\n", sizeof(a));
	return 0;
}

打印结果为8，和刚刚介绍联合体情况不同，char数组是最大值7，这里不是7的原因是，char数组的对齐数还是1，int对齐数为4，7还不是4的整数倍，所以对齐到8。