【C语言进阶12——自定义类型：结构体、位段、枚举、联合（共用体）】

---

前言

本文学习新的知识点，关于自定义类型的，主要内容包括：

• 结构体
• 位段
• 枚举
• 联合（共用体）

---

1、结构体

在基础阶段已经初步学过结构体的相关内容：【C语言基础12——结构体】，进阶阶段在基础阶段之上增加一定的知识点。

1.1 结构的基础知识

• 结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量

1.2 结构的声明

struct tag
{
	member-list;
}variable-list;

struct Stu
{
	char name[20];//名字
	int age;//年龄
	char sex[5];//性别
	char id[20];//学号
}; //分号不能丢

1.3 特殊的声明

• 在声明结构的时候，可以不完全的声明
• 下面两个结构在声明的时候省略掉了结构体标签（tag）
• 匿名结构体的成员如果一样，编译器认为两者是不一样的
• 且这种结构体只能用一次

//匿名结构体类型
struct
{
	int a;
	char b;
	float c;
}x;
struct
{
	int a;
	char b;
	float c;
}a[20], *p;

p = &x;//这是错误的
编译器会把上面的两个声明当成完全不同的两个类型。
所以是非法的。

1.4 结构的自引用

//代码1
struct Node
{
	int data;
	struct Node next;//这是错误的，内存占空间大小不能确定
};

//代码2  正确的
struct Node
{
	int data;
	struct Node* next;
};

//代码3  错误的
typedef struct
{
	int data;
	Node* next;
}Node;

//代码4  正确的
typedef struct Node
{
	int data;
	struct Node* next;
}Node;

1.5 结构体变量的定义和初始化

• 有了结构体类型，接着学习定义变量的几种常见形式：

struct Point
{
	int x;
	int y;
}p1; //声明类型的同时定义变量p1

struct Point p2; //定义结构体变量p2

//初始化：定义变量的同时赋初值。
struct Point p3 = {x, y};

struct Stu //类型声明
{
	char name[15];//名字
	int age; //年龄
};

struct Stu s = {"zhangsan", 20};//初始化

struct Node
{
	int data;
	struct Point p;
	struct Node* next;
}n1 = {10, {4,5}, NULL}; //结构体嵌套初始化

struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化

1.6 结构体内存对齐

• 再掌握了结构体的基本使用后，将学习计算结构体的大小。这个知识点是：结构体内存对齐

1.6.1 结构体的对齐规则

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

1.6.2 练习 1

//练习1
struct S1
{
	char c1;
	int i;
	char c2;
};
int main()
{
	printf("%d\n", sizeof(struct S1));
	return 0;
}

下面对照结构体的对齐规则来分析结构体成员在内存中存储的细节情形：

1、 第一个成员在与结构体变量偏移量为0的地址处

• char c1; c1是第一个成员，从偏移量0开始，char 类型只占1个字节

2、 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处
3.、对齐数 ：编译器默认的一个对齐数 与 该成员大小的较小值。VS中默认的值为8

• int i 大小占4个字节，与VS默认对齐数8比较，取较小值 4 为对齐数。此时偏移量必须为对齐数4的倍数，因此空出偏移量1、2、3，取偏移量4 开始存储 int I，占用了偏移量4、5、6、7，共4个字节。
• char c2 大小占1个字节，与VS默认对齐数8比较，取较小值 1 为对齐数。此时偏移量必须为对齐数1的倍数，取偏移量8 开始存储 char c2，占用了偏移量8，共1个字节。

4、结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍

• 此时结构体总大小为 1+3+4+1共9个字节，但9不是最大对齐数4的倍数（char 对齐数是1、int 对齐数是4）
• 因此又要空出偏移量9、10、11，浪费3个字节
• 此时偏移量0-11一个12个字节，是最大对齐数 4 的倍数
• 最后结构体的大小是12个字节

总结图表及打印结果见下图所示：

1.6.3 练习 2

//练习2
struct S2
{
	char c1;
	char c2;
	int i;
};
int main()
{
	printf("%d\n", sizeof(struct S2));
	return 0;
}

总结图表及打印结果见下图所示：

1.6.4 练习 3

//练习3
struct S3
{
	double d;
	char c;
	int i;
};
int main()
{
	printf("%d\n", sizeof(struct S3));
	return 0;
}

总结图表及打印结果见下图所示：

1.6.5 练习 4

//练习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.7 内存对齐存在的原因?

• 平台原因(移植原因)：
  不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常

• 性能原因：
  数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问

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

因此在设计结构体的时候，既要满足对齐，又要节省空间，让占用空间小的成员尽量集中在一起：

//例如：
struct S1  //12个字节
{
	char c1;
	int i;
	char c2;
};
struct S2	//8个字节
{
	char c1;
	char c2;
	int i;
};

1.8 修改默认对齐数

使用 #pragma 这个预处理指令可以改变 VS 的默认对齐数：

#include 

#pragma pack(8)//设置默认对齐数为8
struct S1
{
	char c1;
	int i;
	char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认

#pragma pack(1)//设置默认对齐数为1
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.9 结构体传参

在前面博文【C语言基础12——结构体】3、结构体传参 已经详细讨论了传参是结构体对象和结构体地址的区别，给出了代码和分析过程。这里不在赘述。

• 函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销
• 如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降
• 结构体传参的时候，要传结构体的地址

2、位段

本小节讲解结构体实现 位段 的细节。位段是和 bit 位关系密接的知识点。

2.1 什么是位段

位段的声明和结构是类似的，但是两者不同：

• 位段的成员必须是 int、unsigned int 或signed int
• 位段的成员名后边有一个冒号和一个数字
• 位段不会对齐的，就是用了省空间的

struct A
{
	int _a:2;	//数字表示变量a在内存中存储占2个bit位
	int _b:5;
	int _c:10;
	int _d:30;
};
printf("%d\n", sizeof(struct A));

结构体大小和位段类型大小相比较：

• 按照结构体类型，大小占16个字节，
• 使用位段类型后，大小占8个字节

位段大小，结果见下图所示：

2.2 位段的内存分配

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

//一个例子
struct S
{
	char a:3;	//数字表示变量a在内存中存储占3个bit位
	char b:4;
	char c:5;
	char d:4;
};

struct S s = {0};

s.a = 10;	//1010   取3个低 bit位，存入内存空间中
s.b = 12;	//1100
s.c = 3;	//0011
s.d = 4;	//0100

下面来分析位段成员在空间是如何存储的，见下图；

调试程序，观察数值在内存中的存储和分析一致。见下图所示:

2.3 位段的跨平台问题

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

位段跟结构体相比：

• 位段可以达到同样的效果，可以更好的节省空间
• 但是位段有跨平台的问题存在

2.4 位段的应用

网络协议传递数据包中需要大量节省空间。

3、枚举

枚举顾名思义就是一一列举。把可能的取值一一列举：如一周7天、性别、月份、颜色等等。

3.1 枚举类型的定义

下面定义的 enum Day ， enum Sex ， enum Color 都是枚举类型。{ }中的内容是枚举类型的可能取值，也叫 枚举常量

enum Day//星期
{
	Mon,
	Tues,
	Wed,
	Thur,
	Fri,
	Sat,
	Sun
};
enum Sex//性别
{
	MALE,
	FEMALE,
	SECRET
}；
enum Color//颜色
{
	RED,
	GREEN,
	BLUE
};
int main()
{
	//联合变量的定义
	enum Day days;
	//计算联合类型的变量的大小
	printf("%d\n", sizeof(days));
	return 0;
}

枚举类型的变量 days 大小结果见下图所示：

这些可能取值都是有值的，默认从0开始，一次递增1。在定义的时候也可以赋初值：

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

3.2 枚举的优点

可以使用 #define 定义常量，选择使用枚举的有点：

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

3.3 枚举的使用

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

4、联合（共用体）

4.1 联合类型的定义

• 联合也是一种特殊的自定义类型
• 这种类型定义的变量也包含一系列的成员，特征是这些成员公用同一块空间
• 联合也叫共用体

//联合类型的声明
union Un
{
	char c;
	int i;
};
int main()
{
	//联合变量的定义
	union Un un;
	//计算联合类型的变量的大小
	printf("%d\n", sizeof(un));
	return 0;
}

联合类型的变量 un 大小结果见下图所示：

4.2 联合的特点

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

union  un
{
	int i;
	char c;
};

int main()
{
	union  un un1;
	printf("%d\n", &(un1.i));
	printf("%d\n", &(un1.c));

	un1.i = 0x11223344;
	un1.c = 0x55;
	printf("%x\n", un1.i);
	return 0;
}

分析代码见下图：

调试过程见下图，与分析一致：

4.3 联合大小的计算

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

union Un1
{
	char c[5]; //对齐数1，
	int i;	//对齐数4
	//最大成员5个字节，不是最大对齐数4的倍数
	//对齐到8个字节
};
union Un2
{
	short c[7];	//对齐数1，
	int i;	//对齐数4
	//最大成员14个字节，不是最大对齐数4的倍数
	//对齐到16个字节
};

int main()
{
	//下面输出的结果是什么？
	printf("%d\n", sizeof(union Un1));
	printf("%d\n", sizeof(union Un2));
	return 0;
}

结果见下图，和分析一致：

4.4 联合的应用——判断机器大小端

在 【C语言进阶1——数据的存储（1）】2.2.3 写程序判断字节序—大小端 中 写过一个程序，根据低字节数据判断当前机器大小端:

int main()
{
	int i = 1;
	if (1 == *(char*)&i) //char* 类型指针，解引用访问低字节，一个字节里的数据
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}
	return 0;
}

这里应用联合的特点来判断大小端：

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

结果见下图：

---

总结

前面在基础阶段学过了结构体，进阶阶段在此基础上增加了一些新的知识点，并且学习了其它的自定义类型：

• 位段、枚举、联合（共用体）
• 结构体传参时，要传j结构体地址
• 位段和联合体的特殊应用
• 枚举常量

这些自定义类型都有自己的应用场景，现阶段是要牢固掌握它们的定义和基本用法，随着后面的深入学习，会碰到使用这些知识点的地方。

下一篇博文将运用目前所学的知识点写一个通讯录基本版的程序。