一篇博客学会系列（2）—— C语言中的自定义类型：结构体、位段、枚举、联合体

秒速五厘米 2023-10-16 14:47 3阅读 0赞

**目录**

前言

1、结构体

1.1、结构体类型的声明

1.2、特殊的结构体类型声明

1.3、结构体的自引用

1.4、结构体的定义和初始化

1.5、结构体成员变量的调用

1.6、结构体内存对齐

1.6.1、offsetof

1.6.2、结构体大小的计算

1.6.3、为什么存在内存对齐？

1.7、 修改默认对齐数

1.8、结构体传参

2、位段

2.1、什么是位段

2.2、位段的内存分配

2.3、位段的跨平台问题

2.4、位段的应用

3、枚举

3.1、枚举类型的定义

3.2、枚举的优点

4、联合体（共用体）

4.1、联合类型的定义

4.2、联合体的特点

4.3、联合大小的计算

![8b6ef96c539648dbb838647edec72b32.gif][]

## 前言 ##

> C语言的**内置类型**有：char、short、int、long、long long、float、double。
> 
> 而这些内置类型**不能够解决所有问题**，生活中会存在一些复杂对象。
> 
> 比如描述一个人，名字、性别、年龄、身高、体重.......
> 
> 描述一本书，书名、作者、出版社.......
> 
> 由于会存在复杂对象，因此C语言就支持了**自定义类型**，这就是这篇博客即将讲到的**结构体、位段、枚举、联合体（共用体）。**

## 1、结构体 ##

> 结构体是一种用户自定义的数据类型，用来将**多个关联的数据项组合到一起**，形成一个完整的数据集合。
> 
> 数组是一组**相同类型**元素的集合，而结构体**可以包含不同类型的数据**，例如整型、字符型、浮点型、数组、指针等等。结构体中的每个数据被称为**成员变量**。

### 1.1、结构体类型的声明 ###

>  *  结构体关键字**struct**
>  *  自定义类型名**tag**
>  *  成员列表**member-list**
>  *  结构体变量名**variable-list**

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

例如描述一个学生：

struct Stu
    {
    	char name[20];//名字
    	int age;//年龄
    	char sex[5];//性别
    	char id[20];//学号
    }s1, s2, s3;//分号不能丢 s1,s2,s3是三个结构体变量，为全局变量
    
    int main()
    {
    	struct Stu s4, s5, s6; //s4,s5,s6是三个结构体变量，为局部变量
    	return 0;
    }

### 1.2、特殊的结构体类型声明 ###

> **匿名结构体类型**在定义时**没有自定义类型名，并且在定义时就创建了结构体变量(s1)。**
> 
> **特点：**因为没有自定义类型名，无法在以后通过自定义类型名进行创建，所以**只能在定义时创建结构体变量。**

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

**【易错提醒】**

> 下面代码是否可行？

struct 
    {
    	char name[20];
    	int age;
    	char sex[5];
    	char id[20];
    }s1;
    
    struct
    {
    	char name[20];
    	int age;
    	char sex[5];
    	char id[20];
    }* p;
    
    int main()
    {
    	p = &s1;  //是否可行？
    	return 0;
    }

【答案 】

> **不可行**， 在编译器看来，虽然两个结构体的成员变量是一样的，但是仍然会认为是两个结构体类型，因此编译器会**报警告**的。

![159263b373974963a25cff2629ae390b.png][]

### 1.3、结构体的自引用 ###

> 在结构体中包含一个类型为该结构体本身的成员可以吗？

struct Node
    {
    	int data;
    	struct Node next;
    };

> 其实可以换一种思路：如果可以直接在结构体内包含本身，那么该结构体大小一定是可以用sizeof()计算的，因为如果可行的话就必然会存储在内存中，而存储在内存中的话又必然会有大小。相反如果无法计算大小，就证明该自引用方式不行。
> 
> 那么当我们运行sizeof计算该结构体大小时候会发现**编译器报错**了，即证明该自引用方式是**错误的。**

![ae587bed982943a393648834a33bed57.png][]

**【正确的结构体自引用】**

> 因为地址（指针）的大小是确定的，所以可以传递指针来实现结构体的自引用。

struct Node
    {
    	int data;
    	struct Node* next; //结构体指针
    };
    
    int main()
    {
    	printf("%d\n", sizeof(struct Node));
    	return 0;
    }

### 1.4、结构体的定义和初始化 ###

struct Point
    {
    	int x;
    	int y;
    }p1;
    //声明类型的同时定义变量p1
    struct Point p2;
    //定义结构体变量p2
    //初始化：定义变量的同时赋初值。
    struct Point p3 = { 1, 2 };
    
    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.5、结构体成员变量的调用 ###

>  *  结构体变量名**.**成员变量名
>  *  结构体指针**->**成员变量名

### 1.6、结构体内存对齐 ###

>  *  我们已经掌握了结构体的基本使用了。
>  *  现在我们深入讨论一个问题：计算结构体的大小。
>  *  这也是一个特别热门的考点： **结构体内存对齐**

> 如果两个结构体的成员变量都一致，那么他们的大小会一样吗？

struct S1
    {
    	char c1;
    	int i;
    	char c2;
    };
    
    struct S2
    {
    	char c1;
    	char c2;
    	int i;
    };
    
    int main()
    {
    	printf("%d\n", sizeof(struct S1));   //结构体大小为多少？
    	printf("%d\n", sizeof(struct S2));   //结构体大小为多少？
    	return 0;
    }

【运行结果】

> 出乎意料的是，S1的大小是12，而S2的大小是8，它们的大小啊是不一致的，这是为什么呢？下面我们介绍一个**宏offsetof**，用这个宏来探究什么导致了S1和S2大小不一。

![b998160c98f945f58f9e8a8ea2f429dd.png][]

#### 1.6.1、offsetof ####

> 宏offsetof用于计算结构体成员相较于起始位置的偏移量，返回的就是偏移量。

【计算S1】

> 首先c1、c2占一个字节，i占四个字节。然后用offsetof计算出偏移量为0、4、8。
> 
> 而S1总大小又为12，那么将c1、i、c2按照偏移量存入内存中后可以观察到，如果S1为12，那么将有6个字节的空间被浪费（红色区域），这是为什么呢？

![d6363d1d098046c69072ca31f5482479.png][]

【计算S2】

> S2计算的大小是8，那么将成员变量按照偏移量存入内存中后，可以观察到被浪费了2个字节的空间（红色区域），为什么会出现浪费的空间，而且浪费的空间还不一样呢？下面将为大家讲解**结构体内存对齐。**

![28db235a2e4d40c295b7575a377877e7.png][]

#### 1.6.2、结构体大小的计算 ####

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

**那么当我们知道了对齐数这个东西之后，我们就来试着自己计算一下s1和s2的大小。**

【手动计算S1】

>  *  第一个成员c1直接放在0偏移处。
>  *  i的自身大小为4，vs默认对齐数为8，**较小值就为4**，因此要放到4的整数倍的位置上，即跳过（浪费）3个字节放在4偏移处，占4个字节。
>  *  c2自身大小为1，vs默认对齐数为8，**较小值就为1**，因此要放到1的整数倍的位置上，任何数都是1的整数倍，因此直接放在i后面就可以了。
>  *  此时还没结束，结构体总大小为**最大对齐数**（每个成员变量都有一个对齐数）的整数倍。c1对齐数1，i对齐数4，c2对齐数1，因此最大对齐数为4，此时大小为9，需要再浪费3个空间，使结构体总大小到达12成为4的倍数，这就完成了一次结构体的计算。

![0f3e13c3586047c8a2824f6147a9e305.png][]

【手动计算S2】

>  *  第一个成员c1直接放在0偏移处。
>  *  c2自身大小为1，vs默认对齐数为8，**较小值就为1**，因此要放到1的整数倍的位置上，任何数都是1的整数倍，因此直接放在c1后面就可以了。
>  *  i的自身大小为4，vs默认对齐数为8，**较小值就为4**，因此要放到4的整数倍的位置上，即跳过（浪费）2个字节放在4偏移处，占4个字节。
>  *  此时还没结束，结构体总大小为**最大对齐数**（每个成员变量都有一个对齐数）的整数倍。c1对齐数1，i对齐数4，c2对齐数1，因此最大对齐数为4。但是此时的大小刚好就为4的倍数，因此不需要在浪费其他空间了，结构体大小就为8。

![f7cc7b355d4b4c2bab3d357abbe5e8f0.png][]

#### 1.6.3、为什么存在内存对齐？ ####

> 当我们了解完结构体内存对齐之后，我们还有一个问题：什么会存在内存对齐呢 ？
> 
> 大部分的参考资料中都涉及到**两种原因**：
> 
> **1. 平台原因(移植原因)：**  
> 不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常
> 
> **2. 性能原因：**  
> 数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。

**总体来说：**

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

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

> 让占用空间**小的成员尽量集中**在一起。例如上面作为例子使用的S1和S2，它们的成员一模一样，但是S1和S2所占空间的大小有了一些区别，就是因为S2将小的成员放在了一起。

struct S1
    {
    	char c1;
    	int i;
    	char c2;
    };                      //结构体大小12
    
    struct S2
    {
    	char c1;
    	char c2;
    	int i;
    };                      //结构体大小8

### 1.7、 修改默认对齐数 ###

> 之前我们见过了 **\#pragma** 这个预处理指令，这里我们再次使用，可以改变我们的默认对齐数。

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

【运行结果】

> 这里非常好理解，对齐数设置为8的情况我们在上面已经计算过了，那么设置为1的时候就等于没有对齐了，因为任何数都是1的整数倍，所以直接就等于1+4+1 = 6。

![2b375132c7bc4edba2725678d377a468.png][]

### 1.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;
    }

【答案】

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

## 2、位段 ##

> 位段的出现是为了节省空间的。

### 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; //_c占用10个bit位的空间
    	int _d : 30; //_d占用30个bit位的空间
    };
    
    int main()
    {
    	printf("%d\n", sizeof(struct A));
    	return 0;
    }
    
    
    //提示：1个字节等于8个bit位

![0847bce28bb14c659e9793315bbd1479.png][]

> 正常情况下四个int类型开辟出来的大小为16个字节，但是如果使用上面的代码实现的话只用了8个字节，下面就来讲解一下位段的内存分配。

### 2.2、位段的内存分配 ###

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

struct S
    {
    	char a : 3;
    	char b : 4;
    	char c : 5;
    	char d : 4;
    };
    
    
    int main()
    {
    	struct S s = { 0 };
    
    	s.a = 10;
    	s.b = 12;
    	s.c = 3;
    	s.d = 4;
    
    	int ret = sizeof(struct S);
    	printf("%d\n", ret);
    	return 0;
    }

【运行结果】**Visual Studio 2022环境下测试结果**

> **结果为3个字节。**
> 
> 疑问**：**3+4+5+4 = 16bit位，1个字节等于8个bit位，为什么不是开辟2个字节呢？
> 
> 我们可以在**内存**存放的值中找到答案。

![8cca7b3c7d1c4872995287ffeb1e949b.png][]

> 从**图解**可以得出结论：当空间不够存放下一个成员时，剩下的空间不会被使用，而是会开辟另外一个空间然后将内容存放到新开辟的空间中去，因此上述代码的结果才会是是3而不是2。

### 2.3、位段的跨平台问题 ###

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

总结：

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

### 2.4、位段的应用 ###

> 网络协议栈，网络底层传输数据。
> 
> 在当今的互联网时代下，通过网络传输数据已经非常普遍了，那么大家有没有想过，当我们发送的一条短信，一条微信消息时，网络传输部分是怎样处理的，它是只传输了消息本身吗？当然不是，一条最简单的消息都要包含许多其他的数据，比如这条消息的发出时间，发送者的ip地址，发送对象的ip地址等等等等。一条消息包含了那么多数据，那么如果没有位段的出现，就会导致单条消息传输的体积过大，会导致网络负载过大，不利于我们的日常使用和服务器的数据存储。使用位段就能很好的压缩体积大小，使得消息更加小而轻便。

![468ddae8523441e6be05339e19589745.png][]

## 3、枚举 ##

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

### 3.1、枚举类型的定义 ###

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

enum Day//星期
    {
    	Mon,   //枚举的可能取值是默认从0开始的。
    	Tues,
    	Wed,
    	Thur,
    	Fri,
    	Sat,
    	Sun
    };
    
    enum Sex//性别
    {
    	MALE,
    	FEMALE,
    	SECRET
    };
    
    enum Color//颜色
    {
    	RED,
    	GREEN,
    	BLUE
    };

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

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

### 3.2、枚举的优点 ###

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

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

## 4、联合体（共用体） ##

### 4.1、联合类型的定义 ###

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

union Un
    {
    	char c;
    	int i;
    };

### 4.2、联合体的特点 ###

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

union Un
    {
    	char c;
    	int i;
    };
    
    int main()
    {
    	union Un un;
    	printf("%d\n", sizeof(un));
    	printf("%p\n", &(un));
    	printf("%p\n", &(un.c));
    	printf("%p\n", &(un.i));
    	return 0;
    }

![03c6df14048546e4a5fc694cb5eae5c6.png][]

### 4.3、联合大小的计算 ###

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

union Un
    {
    	char c[5];  //大小为5，对齐数为1
    	int i;      //大小为4，对齐数为4
    };
    
    int main()
    {
    	printf("%zd\n", sizeof(union Un));
    	return 0;
    }

【运行结果】

> 最大成员大小为5，但是最大对齐数是4，所以需要对齐到8。

![0a8e13e1f4f7442d8a3be1328bcb8439.png][]

![287dee1b30cc4e06a02f832b401cde9f.gif][]

**如果觉得作者写的不错，求给博主一个大大的点赞支持一下，你们的支持是我更新的最大动力！**

[8b6ef96c539648dbb838647edec72b32.gif]: https://img-blog.csdnimg.cn/8b6ef96c539648dbb838647edec72b32.gif
[159263b373974963a25cff2629ae390b.png]: https://img-blog.csdnimg.cn/159263b373974963a25cff2629ae390b.png
[ae587bed982943a393648834a33bed57.png]: https://img-blog.csdnimg.cn/ae587bed982943a393648834a33bed57.png
[b998160c98f945f58f9e8a8ea2f429dd.png]: https://img-blog.csdnimg.cn/b998160c98f945f58f9e8a8ea2f429dd.png
[d6363d1d098046c69072ca31f5482479.png]: https://img-blog.csdnimg.cn/d6363d1d098046c69072ca31f5482479.png
[28db235a2e4d40c295b7575a377877e7.png]: https://img-blog.csdnimg.cn/28db235a2e4d40c295b7575a377877e7.png
[0f3e13c3586047c8a2824f6147a9e305.png]: https://img-blog.csdnimg.cn/0f3e13c3586047c8a2824f6147a9e305.png
[f7cc7b355d4b4c2bab3d357abbe5e8f0.png]: https://img-blog.csdnimg.cn/f7cc7b355d4b4c2bab3d357abbe5e8f0.png
[2b375132c7bc4edba2725678d377a468.png]: https://img-blog.csdnimg.cn/2b375132c7bc4edba2725678d377a468.png
[0847bce28bb14c659e9793315bbd1479.png]: https://img-blog.csdnimg.cn/0847bce28bb14c659e9793315bbd1479.png
[8cca7b3c7d1c4872995287ffeb1e949b.png]: https://img-blog.csdnimg.cn/8cca7b3c7d1c4872995287ffeb1e949b.png
[468ddae8523441e6be05339e19589745.png]: https://img-blog.csdnimg.cn/468ddae8523441e6be05339e19589745.png
[03c6df14048546e4a5fc694cb5eae5c6.png]: https://img-blog.csdnimg.cn/03c6df14048546e4a5fc694cb5eae5c6.png
[0a8e13e1f4f7442d8a3be1328bcb8439.png]: https://img-blog.csdnimg.cn/0a8e13e1f4f7442d8a3be1328bcb8439.png
[287dee1b30cc4e06a02f832b401cde9f.gif]: https://img-blog.csdnimg.cn/287dee1b30cc4e06a02f832b401cde9f.gif