【C语言】结构体+位段+枚举+联合(2)

大家好，我是苏貝，本篇博客带大家了解结构体和位段以及枚举，如果你觉得我写的还不错的话，可以给我一个赞👍吗，感谢❤️

---

这是这个系列的第二篇，上一篇详细介绍了结构体的基本知识，详情请点击

一.结构体

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

你可以看见，答案居然不一样，可是两个结构体的成员是一样的呀，只是三个成员变量的顺序不同罢了。那我们现在就用可以计算结构体成员相较于起始位置的偏移量的宏offsetof

offserof括号里面的第一个参数是结构体类型，第二个是结构体成员。头文件：

#include
#include

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

我们发现，三个成员变量的顺序不同时，它们中的相同位置的相较于起始位置的偏移量不同，为什么呢？让我们来了解一下结构体的内存对齐

如何计算？
首先得掌握结构体的对齐规则

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

下面我用的是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;
}
1
2
3
4
5
6
7
8
9
10
11

创建一个类型为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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

创建一个类型为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

为什么存在内存对齐?

大部分的参考资料都是如是说的：

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

总体来说：

结构体的内存对齐是拿空间来换取时间的做法。

那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到：

让占用空间小的成员尽量集中在一起

例如：将第一段代码写成第二段代码

struct S1
{
	char c1;
	int i;
	char c2;
};
1
2
3
4
5
6

struct S2
{
	char c1;
	char c2;
	int i;
};
1
2
3
4
5
6

---

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

---

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

答案：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;
};
1
2
3
4
5
6
7

A就是一个位段类型。那位段A的大小是多少

printf("%d\n", sizeof(struct A));
1

2.2 位段的内存分配

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

以下代码空间是如何开辟的？

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

因为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 位段的跨平台问题

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

总结：

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

---

三. 枚举

枚举顾名思义就是把可能的取值一一列举。比如我们现实生活中：一周的星期一到星期日是有限的7天，可以一一列举，性别有：男、女、保密，也可以一一列举，月份有12个月，也可以一一列举

3.1 枚举类型的定义

enum Gender
{
	MALE,
	FEMALE,
	SECRET
};

enum Day
{
	MON,
	TUES,
	WED,
	THUR,
	FRI,
	SAT,
	SUN
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

以上定义的 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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

范例2：
在定义的时候部分赋初值，后面的一次递增1

enum Gender
{
	MALE = 3,
	FEMALE,
	SECRET
};
//下面的main函数和范例1一样，就不再写了
1
2
3
4
5
6
7

范例3：
在定义的时候全部赋初值

enum Gender
{
	MALE = 3,
	FEMALE = 7,
	SECRET = 1
};
//下面的main函数和范例1一样，就不再写了
1
2
3
4
5
6
7

3.2 枚举的使用

只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。如果将整型赋给枚举变量，可能会报错

enum Gender
{
	MALE,
	FEMALE,
	SECRET
};

int main()
{
	enum Gender gender = FEMALE;
	enum Gender gender1 = 2;//ok?
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

3.3 枚举的优点

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

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

---

四. 联合（共用体）

4.1 联合类型的定义

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

//联合类型的声明
union Un
{
	char c;
	int i;
};
//联合变量的定义
union Un un;
//计算1个联合体变量的大小
printf("%d\n", sizeof(un));
1
2
3
4
5
6
7
8
9
10

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
2
3
4
5
6
7
8
9
10
11
12
13

它们的输出结果相同，证明了联合的成员是共用同一块内存空间的
注意：联合体在同一时间只能使用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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

其实，还有一种很巧妙的方法，用联合体
因为联合的成员是共用同一块内存空间的，所以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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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
2
3
4
5
6
7
8
9
10
11

范例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;
}
1
2
3
4
5
6
7
8
9
10
11

---

好了，那么本篇博客就到此结束了，如果你觉得本篇博客对你有些帮助，可以给个大大的赞👍吗，感谢看到这里，我们下篇博客见❤️