本章重点：
1.结构体
1.1 结构体类型的声明
1.2 结构的自引用
1.3 结构体变量的定义和初始化
1.4 结构体内存对齐
1.5 结构体传参
1.6 结构体实现位段(位段的填充&可移植性)
2.枚举
2.1 枚举类型的定义
2.2 枚举的优点
2.3 枚举的使用
3.联合
3.1 联合类型的定义
3.2 联合的特点
3.3 联合大小的计算
在前期我讲解过一次初始结构体，今天我们仔细讲解自定义类型：
初始结构体链接：
s7——结构体_c语言实现s7协议_wangjiushun的博客-CSDN博客
类型：内置类型和自定义类型
内置类型：语言自身定义的类型，如:char short int……
自定义类型(聚合类型)：结构体，枚举，联合
为什么要有自定义类型？
答:生活中有些(复杂)对象要被描述的话，不能简单使用单个内置类型。
如：
学生：名字+年龄+性别+成绩
书：书名+定价+书号等
结构成员用{}聚合在一起，所以也可叫聚合类型。
结构体
1. 结构体的声明
1.1 结构体的基础知识
结构是一些值的集合，这些值称为成员变量，结构的每个成员可以是不同类型的。
回顾：成员变量的类型-->结构成员可以是变量、数组、指针，甚至是其他结构体。
vs数组：数组也是一些值的集合，但是这些值的类型是相同的。
1.2 结构的声明
struct tag//①struct结构体关键字，②tag结构体标签名(见明知意){member-list;//成员列表1~N}variable-list;//变量列表1~N
//定义学生:名字+年龄
//在C语言中：结构体类型是struct+tag，
//在C++中可以直接用tag表示
//不使用typedef
struct stu
{
char name[20];
int age;
}s1,s2;//声明类型的同时定义变量，s1,s2两个结构体变量是全局变量
//使用typedef
typedef struct stu
{
char name[20];
int age;
}stu;//stu不是结构体变量，是结构体类型的别名
注意：结构体使用typedef重命名只能在结构体声明时或声明后，不能在结构体之前重命名(报错:无法解析的外部命令，因为代码是由上到下依次执行的)。
1.3 特殊的声明(使用场景少)
在声明结构的时候，可以不完全的声明
匿名结构体：结构在声明的时候省略掉结构体标签(tag)。
注意：只能在声明时使用一次(即只能在声明的同时定义结构体变量，不能在其他地方再使用该结构体创建变量)。
//特殊的声明：
//匿名结构体(不完全声明)：在结构声明的时候省略掉结构体标签(tag)
struct
{
int a;
char b;
float c;
}x;
struct
{
int a;
char b;
float c;
} * p;
int main()
{
p = &x;//合法吗？
//答：非法的。
//警告：虽然两个结构体成员是一样的，但是编译器会把上面两个声明当成两个完全不同的类型
//匿名结构体只能使用一次，且是在声明时，该语句相当于又使用一次结构体
return 0;
}
1.4 结构的自引用
在结构中包含一个类型为该结构本身的成员是否可以呢？
代码1：
//结构的自引用
//在结构中包含一个类型为该结构本身的成员是否可以呢？
//代码1
struct Node
{
int data;
struct Node next;
};思考：代码1可以吗；如果可以，那sizeof(struct Node)是多少？
答：①代码1不可以实现结构的自引用，因为在一个结构体还没有完全定义之前调用该结构体了，C是自上而下编译的，走到struct Node next；这一句的时候，编译器发现struct Node结构并没有定义完整，所以报错。
②如果可以，sizeof(struct Node)=4+4+4+……死递归下去，大小就是无限大。
代码2：正确的结构自引用
正确的结构自引用：定义成结构体的指针，结构的指针不受结构的内容影响，它只是一个指针，指向你定义的一个结构，至于这个结构完不完整是什么，它都不需要知道。因此编译器能令其通过。
结构体自引用其实就是数据结构中的链表，
如下图，了解即可，后期会详细讲解。
//正确的自引用方式
//代码2
struct Node
{
int data;
struct Node* next;
};代码3：使用typedef:重命名的别名自引用可以吗
//使用typedef
//代码3
typedef struct Node
{
int data;
Node* next;//这样写可以，可行吗？
//答：不可以，报错，编译器找到一个意外标识符，请确保标识符在使用前声明
//在结构体自引用时，不能使用结构体的别名，因为代码是由上到下依次执行的
}Node;//结构体类型的别名代码4：使用typedef时的正确做法
//解决方案
//代码4
typedef struct Node
{
int data;
struct Node* next;//结构体的自引用，使用结构体的本名
};1.5 结构体变量的定义和初始化
①变量的定义：通过类型创建变量；
②变量的初始化：定义变量的同时赋初值
代码示例：
//结构体变量的定义和初始化
struct P
{
int x;
char ch;
}p1 = { 2, 'a'};//方式①：声明类型的同时定义结构体变量p1(全局的),并初始化
struct P p3 = { 3,'b' };//方式②：定义结构体变量p3(全局的)，并初始化
struct S
{
double d;
struct P p2;//结构体嵌套
float f;
};
int main()
{
struct S s = { 3.2,{4,'c'},6.2f };//方式③：定义结构体变量s(局部的)，并初始化
struct S s1 = { .f = 3.1f,.p2.ch = 'd',.p2.x = 6,.d = 9.1 };//乱序初始化
return 0;
}1.6 结构体内存对齐
通过前面知识点，我们已经掌握了结构体的基本使用。
现在我们深入讨论一个问题：计算结构体的大小。
这是一个热门的考点：结构体内存对齐。
考点：
如何计算？
首先得掌握结构体的对齐规则：
1.结构体的第一个成员，对齐到结构体变量在内存中存放位置的0偏移处。
2.从第二个成员开始，每个成员变量都要对齐到(一个对齐数)的整数倍处。
①对齐数=编译器默认的一个对齐数与结构体成员自身大小的较小值。
②VS:默认对齐数为8；
Linux gcc：没有默认对齐数，对齐数就是结构体成员自身大小。
3.结构体总大小，必须是所有成员变量的对齐数中最大对齐数的整数倍。
4.如果嵌套结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数(含嵌套结构体的对齐数)的整数倍。
练习：
案例1：
/结构体内存对齐
//计算结构体内存的大小
//案例1：结构体成员个数、类型一样，改变其成员顺序，结构体大小怎么样？
#include<stdio.h>
struct S1
{
char ch1;
int i;
char ch2;
};
struct S2
{
char ch1;
char ch2;
int i;
};
int main()
{
printf("%d\n", sizeof(struct S1));//12
printf("%d\n", sizeof(struct S2));//8
return 0;
}图解：
①struct S1
②struct S2
案例2：
//案例2
#include<stdio.h>
struct S3
{
double d;
char ch;
int i;
};
int main()
{
printf("%d\n", sizeof(struct S3));//16
return 0;
}图解：
案例3：结构体嵌套问题
//案例3：结构体嵌套问题
#include<stdio.h>
struct S3
{
double d;
char ch;
int i;
};
struct S4
{
char ch1;
struct S3 s3;
double d;
};
int main()
{
printf("%d\n", sizeof(struct S4));//32
return 0;
}图解：
通过这些案例我们知道了计算，但是为什么存在内存对齐呢？
大部分的参考资料都是这么说的：
1.平台原因(移植原因)
不是所有的硬件平台都能访问任意地址上的任意数据；某些硬件平台只能在某些地址处取某些特定的数据，否则抛出硬件异常(例：int-->对齐到4的整数倍)
2.性能原因
数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。
图释：
总体来说：
结构体的内存对齐是拿空间来换取时间的做法。
那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到：
答：让占用空间小的成员尽量集中在一起。
例如：
struct S1
{
char c1;
int i;
char c2;
};
struct S2
{
char c1;
char c2;
int i;
};
#include <stdio.h>
int main()
{
printf("%d\n", sizeof(struct S1));//12
printf("%d\n", sizeof(struct S2));//8
return 0;
}s1和s2类型的成员虽然一模一样，但是s1和s2所占空间的大小有区别。
1.7 查看偏移量与修改默认对齐数
（1）offsetof
1.头文件：“stddef.h”
2.功能：
在msdn上，该宏被写作：
size_t offsetof(structName,memberName);
第一个参数是结构体的名字，第二个参数是结构体成员的名字。该宏返回结构体structName中成员memberName的偏移量。偏移量是size_t类型的。
（2）#pragma pack
程序编译器对结构的存储的特殊处理确实提高CPU存储变量的速度，但是有时候也带来了一些麻烦，我们也屏蔽掉变量默认的对齐方式，自己可以设定变量的对齐方式。
1.#pragma pack(n)来设定变量以n字节对齐方式。（n：可选参数；指定packing的数值，以字节为单位；缺省数值是8，合法的数值分别是1、2、4、8、16。调用pack时不指定参数，n将被设成默认值。）
2.#pragma pack () /*取消指定对齐，恢复缺省对齐,等价于#pragma pack(pop)*/
代码实例：
#include<stdio.h>
#include<stddef.h>
#pragma pack(1)//设置默认对齐数为1
struct S1
{
char c1;
int i;
char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认
int main()
{
//查看偏移量
printf("%d\n", offsetof(struct S1, c1));//0
printf("%d\n", offsetof(struct S1, i));//1
printf("%d\n", offsetof(struct S1, c2));//5
//计算结构体的大小
printf("%d\n", sizeof(struct S1));//6
return 0;
}
图示：
结论：
结构在对齐方式不合适的时候，我们可以自己更改默认对齐数。
1.8 结构体传参
先看代码：
#include<stdio.h>
struct S
{
int data[1000];
int num;
};
//结构体传参
void print1(struct S s)
{
printf("%d\n", s.num);
}
//结构体地址传参
void print2(struct S* ps)
{
printf("%d\n", ps->num);
}
int main()
{
struct S s = { {1,2,3,4}, 1000 };
print1(s); //传结构体
print2(&s); //传地址
return 0;
}上面的print1和print2函数哪个好些？
答案是：首选print2函数
原因：
函数传参的时候，参数是需要压栈的，会有时间和空间上的系统开销。
如果传递一个结构体对象的时候，结构体过大,参数压栈的系统开销比较大，所以会导致性能的下降。
结论：
结构体传参的时候，最好传结构体的地址。
2. 位段
结构体讲完，我们就得讲讲结构体实现位段的能力。
2.1 什么是位段
位段的声明和结构是类似的，有两个不同：
1、位段的成员必须是int，unsigned int或signed int类型。（大量测试，char类型也可以；但是成员的类型通常为相同类型）
2、位段的成员名后边有一个冒号和一个数字。（①位段 - 位：二进制位，②且冒号后面的数字不能大于开辟类型的大小）
例如：
//位段 - 位 ：二进制位
struct A
{
int _a : 2;
int _b : 5;
int _c : 10;
int _d : 30;
};
#include<stdio.h>
int main()
{
//位段式的结构体A的大小是多少？
printf("%d\n", sizeof(struct A));
return 0;
}答：A的大小为8个字节，为什么呢？
2.2 位段的内存分配
1、位段的成员可以是int，unsigned int，signed int或者是char（属于整形家族）类型
2、位段的空间上是按照需要以4个字节(int)或者1个字节（char）的方式来开辟的（用多少开辟多少，不够再开辟）
3、位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。
图释结构A的大小为什么是8：
再来一个例子：
struct S
{
char a : 3;
char b : 4;
char c : 5;
char d : 4;
};
#include<stdio.h>
int main()
{
//s在空间是如何开辟的？
struct S s = { 0 };//将s初始化为0便于观察值的变化
s.a = 10;
s.b = 12;
s.c = 3;
s.d = 4;
return 0;
}图示：
2.3 位的跨平台问题
1、int位段被当成有符号还是无符号数是不确定的。
2、位段中最大数目不能确定（int在16位机器最大16,32位机器最大32，写成27，在16位机器会出问题）
3、位段中的成员在内存中从左向右分配，还是从右向左分配标准未定义。
4、当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。
总结：
与结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。
2.4 位段的应用
数据的传输，在数据的传输中我们要将其封装成数据包，如图：
我们看到有许多部分组成，如果我们不使用位段 数据包就较大，网络传输就慢，如果使用位段节省空间数据包小，传输就快了。
3. 枚举
枚举顾名思义就是一一列举。
把可能的取值一一列举。
如我们生活中：
一周的星期一到星期日是有限的7天，可以一一列举。
性别有：男、女、保密，也可以一一列举
月份有12个月，也可以一一列举
这就可以使用枚举。
3.1 枚举类型的定义
enum Day//星期
{
Mon,
Tues,
Wed,
Thur,
Fri,
Sat,
Sun
};
enum Sex//性别
{
MALE,
FEMALE,
SECRET
};
enum Color//颜色
{
RED,
GREEN,
BLUE
};以上定义的enum Day，enum Sex，enum Color都是枚举类型。
{}中的内容是枚举类型的可能取值，也叫枚举常量。
这些可能取值都是有值的，默认从0开始，一次递增1，当然在定义的时候也可以赋初值。
例如：
#include<stdio.h>
enum Sex//性别
{
//枚举类型的可能取值——枚举常量
//默认从0开始，一次递增1
MALE,//0
FEMALE,//1
SECRET//2
};
enum Color//颜色
{
//枚举常量，在定义是可以赋初值
RED = 1,
GREEN,
BLUE = 5
};
int main()
{
//打印性别的枚举常量
printf("%d %d %d\n", MALE, FEMALE, SECRET);
//打印颜色的枚举常量
printf("%d %d %d\n", RED, GREEN, BLUE);
return 0;
}
运行结果：
3.2 枚举的优点
为什么使用枚举？
我们可以使用#define定义常量，为什么要使用枚举？
枚举的优点：
1、增加代码的可读性和可维护性（如我们以前实现的通讯录，选择语句是使用的1,2,3等字面常量，那现在我们可以使用枚举来定义枚举常量实现见名知意）
2、和#define定义的标识符比较枚举有类型检查，更加严谨
3、防止命名污染（封装）
4、便于调试（#define在预编译时就已经被替换了）
5、使用方便，一次可以定义多个常量
3.3 枚举的使用
enum Color//颜色
{
RED = 1,
GREEN = 2,
BLUE = 4
};
int main()
{
enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。
clr = 5; //ok??,在VS中虽然不报错，但是是不严谨的，在C++中直接报错
return 0;
}tip：枚举类型的大小与int一样
4. 联合（共用体）
4.1 联合类型的定义
联合也是一种特殊的自定义类型
这种类型定义的变量也包含一系列的成员，特征是这些成员共用同一块空间（所以联合也叫共用体）。
例如：
#include<stdio.h>
//联合类型的声明
union Un
{
char c;
int i;
};
int main()
{
//联合变量的定义
union Un un;
//打印联合变量的大小
printf("%d\n", sizeof(un));
//打印联合变量的起始地址
printf("%p\n", &un);
//打印联合成员c的起始地址
printf("%p\n", &un.c);
//打印联合成员i的起始地址
printf("%p\n", &un.i);
return 0;
}运行结果：
图示：
4.2 联合的特点
1、联合的成员是共用同一块空间的，这样一个联合变量的大小；至少是最大成员的大小（因为联合至少得有能力保存最大的那个成员）。
2、理解：一般联合一次只能使用一个成员不能几个成员共同使用，就像超市的存物柜。
比如：
union Un
{
int i;
char c;
};
#include<stdio.h>
int main()
{
union Un un;
//下面输出的结果是什么？
un.i = 0x11223344;
un.c = 0x55;
printf("%x\n", un.i);
return 0;
}运行结果：
为什么呢？
因为联合的成员是共用同一块空间的，已经使用了联合成员i赋值11223344，又使用联合成员c赋值55，所以44被55覆盖。（注意：同时使用联合成员并不是将前一个成员的存储空间销毁，而是将前一个成员共用空间的值覆盖；销毁是将存储空间还给操作系统。）
面试题：判断计算机的大小端存储（在之前数据的存储中我们使用指针的方式，现在使用联合方式）
int check_sys()
{
union UN
{
char c;
int i;
}un;
un.i = 1;
//0x 00 00 00 01
//低地址-------------高地址
//01 00 00 00 - 小端（数据的低位放在低地址，高位放在高地址）
//00 00 00 01 - 大端
return un.c;//小端返回1，大端返回0
}
#include<stdio.h>
int main()
{
if (check_sys())
{
printf("小端\n");
}
else
{
printf("大端\n");
}
return 0;
}
4.3 联合大小的计算
1、联合的大小至少是最大成员的大小
2、当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍（对齐数=编译器默认对齐数与联合成员自身大小的较小值）
比如：
union Un1
{
char c[5];
int i;
};
union Un2
{
short c[7];
int i;
};
#include<stdio.h>
int main()
{
//下面输出两个联合的大小
printf("%d\n", sizeof(union Un1));//Un1最大成员大小为5，最大对齐数4——>联合大小8
printf("%d\n", sizeof(union Un2));//Un2最大成员大小14，最大对齐数4——>联合大小16
return 0;
}自定义类型结构体使用场景多，枚举、联合较少，但是应该在平时多写代码多感悟。
