【C语言进阶】自定义类型之结构体
目录
- 一：结构体
- 1.1：结构的基础知识：
- 1.2：结构的声明：
- 1.3：特殊声明（匿名结构体）：
- 1.4：结构的自引用：
- 1.5：结构体变量的定义和初始化：
- 1.6：结构体的内存对其：
- 1.6.1：为什么存在内存对齐？
- 1.7：修改默认对齐数：
- 1.8：结构体传参：
- 二：位段
- 2.1：什么是位段？
- 2.2：位段的内存分配
- 2.3：验证vs2019上位段的内存分配和使用
- 2.4：位段的跨平台问题
- 2.5：位段的应用
前言：
今天分享的内容是自定义类型之一的结构体。C语言本身为我们提供了一些类型，比如 int、char、float等等，我们可以利用这些类型来定义一些比较简单的事物，那如果要定义一本书呢？C语言自身提供的这些类型，好像都无法精准的帮我们定义出一本书，一本书包含：书名、作者、出版社等主要信息，只有知道了这些信息，我们才能准确的描述一本书。为此，C语言为我们提供了结构体这种自定义类型，我们可以根据自己的需求去定义结构体里的成员列表，用来描述不同类型行的事物。可见自定义类型给我们提供了无限的遐想空间，接下来就让我们一起来看看，结构体里都有哪些有趣的知识吧！
一：结构体
1.1：结构的基础知识：
结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量
数组也是一些值的集合，但一个数组里面存的都是相同类型的元素
1.2：结构的声明：
struct tag//tag是标签 { member-list;//成员列表，可以是一个或者多个 }variable-list;//变量列表struct stu { char name[20];//名字 int age;//年龄 char sex[5];//性别 char id[20];//学号 }s1,s2;//在这里创建两个struct stu类型的结构体变量，注意结尾的分号 //这里的s1和s2是全局变量 int main() { struct stu s3, s4;//这里的s3和s4是局部变量 return 0; }对结构体类型进行重命名：
把结构体类型struct stu重新命名成stu，以后就可以直接用stu来定义变量
typedef struct stu { char name[20];//名字 int age;//年龄 char sex[5];//性别 char id[20];//学号 } stu;//这里的stu表示类型 //把结构体类型struct stu重新命名成stu //typedef struct stu stu;//第二种重命名方式 int main() { stu s3, s4;//直接利用stu来定义变量 return 0; }1.3：特殊声明（匿名结构体）：
struct { char name[20];//名字 int age;//年龄 }s1;//s1只能在这里定义 int main() { return 0; }上面的结构在声明的时候省略掉了结构体标签（tag），这种类型的结构体变量只能紧跟着结构体的声明去定义，匿名结构体类型只能在声明的时候用一次
struct { int a; char b; float c; }x; struct { int a; char b; float c; } * p; int main() { p = &x; return 0; }上面这段代码中声明了两个匿名结构体类型，在第一个匿名结构体的声明后面定义了一个x，在第二个匿名结构体变量的声明后面定义了一个指针p，在主函数里面取x的地址放到p里面，这样写可以吗？答案是不可以。虽然这两个匿名结构体的成员一模一样，但是由于匿名结构体只能用一次，所以编译器会把上面的两个声明当成完全不同的两个类型。在编译的时候就会报警告。
1.4：结构的自引用：
在结构中包含一个类型为该结构本身的成员是否可以呢？就像下面这样：
//代码1 struct Node { int data; struct Node next; };答案是不可以，因为这里的next是一个同类型的结构体变量，那next里面又有一个next，就这样一直无限套娃套下去，自然是不可以的，所以这样肯定不能叫做结构体的自引用，正确的自引用应该像下面这样：
struct Node { int data; struct Node* next;//结构体的声明里面包含一个同类型的结构体指针 };自引用时需注意！！
typedef struct Node { int data; Node* next; }Node;如上代码中的自引用是错误的，这里利用typedef把结构体重命名成Node，然后在结构体的成员列表里利用Node来定义一个指针变量，这样是行不通，因为程序在编译的时候都还没走到重命名的Node，就在成员列表里面遇见了Node，此时编译器就无法得知这里的Node到底是什么。下面这样写是正确的
typedef struct Node { int data; struct Node* next; }Node;1.5：结构体变量的定义和初始化：
声明类型的同时定义变量
struct Point { int x; int y; }p1; //声明类型的同时定义变量p1单独利用类型来定义变量
struct Point { int x; int y; };//先声明一个结构体 struct Point p2; //定义一个全局的结构体变量p2 int main() { struct Point p3;//定义一个局部的结构体变量p3 return 0; }结构体变量的初始化
struct Point { int x; int y; }p1={0,0}; struct Point p2 = {1,2}; //初始化 int main() { struct Point p3 = {3,4};//初始化 return 0; }结构体嵌套结构体的初始化
struct Point { int x; int y; }p1={0,0}; struct Point p2 = {1,2}; //初始化 struct S { int num; char ch; struct Point p;//嵌套一个struct Point类型的结构体p float d; }; int main() { struct Point p3 = {3,4};//初始化 struct S s = { 20,'w',{1,2},3.14f };//结构体嵌套结构体的初始化 struct S s2 = { .ch = 'w',.d = 3.14f,.num = 20,.p.x = 1,.p.y = 2 };//乱序初始化 printf("%d %c %d %d %f\n", s.num, s.ch, s.p.x, s.p.y, s.d);//打印s printf("%d %c %d %d %f\n", s2.num, s2.ch, s2.p.x, s2.p.y, s2.d);//打印s2 return 0; }1.6：结构体的内存对其：
先上例子：下面声明了两个结构体类型，分别是struct S1和struct S2，它们的成员列表都定义了两个char型变量和一个整型变量，只是定义的先后顺序有所不同，接下来我们来计算这两个结构体类型的大小（单位是字节），大家猜猜，这两个结构体的大小是多少？他俩的大小相等嘛？
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; } //结果： 12 8这里计算结果显示struct S1的大小是12个字节，而struct S2的结果是8个字节，为什么是这样的结果呢？这就涉及到结构体内存对齐的知识了。
对齐规则
- 第一个成员在结构体变量偏移量为0的位置
- 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
- 对齐数=编译器默认的一个对齐数与该成员自身大小的较小值
- vs中的默认对其数是8，Linux和gcc都没有默认对齐数，对齐数就是成员自身大小
- 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍
- 如果嵌套了结构体的情况，嵌套的结构体对齐到该结构体中最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体成员中的对齐数）的整数倍
- 结构体成员中如果有数组，可以这样来理解：比如结构体中有一个int c[5];，其实这就相当于这个结构体中放了5个int型的变量。
创建一个struct s1类型的变量，探究其在内存中的存储
这里定义了一个struct S1类型的变量s，接下来就要给这个s在内存中开辟空间。首先为结构体中的char c1开辟空间，根据对齐规则：第一个成员在结构体变量偏移量为0的位置，所以为c1开辟的空间如上图中的粉色区域。接下来为结构体中的int i开辟空间，根据对齐规则：其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。这里i是一个整型变量，它的自身大小是4个字节，当前的编译环境是vs2019，它的默认对齐数是8，取两者的较小值，即此时i变量的对齐数应该是4，偏移量为1、2、3的地址都不是这个对齐数的整数倍，所以i的地址应该从偏移量为4的地址处开始，向后开辟4个字节用来存放i，如上图中的紫色区域。最后为结构体中的char c2开辟空间，c2遵循的规则和i一样，c2是一个字符型变量，它的自身大小是1，默认大小是8，取两者的较小值，就是1，偏移量为8的地址是1的整数倍，所以如上图中的绿色区域就是为c2开辟的存储空间。此时已经为结构体中的所有成员都开辟了空间，此时结构体的大小是9个字节，根据规则：结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。因此，当前结构体的总大小不符合对齐规则，那就只能继续扩容，直到满足要求为止。c1的对齐数是1，i的对齐数是4，c2的对齐数是1，取对齐数最大的，也就是4，结构体的总大小就得是4的整数倍，当结构体的大小增加到12个字节的时候就满足对齐规则了。因此最终结构体变量s的大小是12个字节
创建一个struct s2类型的变量，探究其在内存中的存储
这里就不再详细介绍struct S2 s的创建过程，大家可以试着自己分析一下，最后再结合上图看看分析出来的结果和上图是否相同。
验证偏移量：
我们可以通过offsetof这个宏来计算结构体成员相对于结构体起始地址的偏移量，这个宏有两个参数。第一个参数是结构体的类型，第二个参数是结构体的成员名，它的返回值是一个整型也就是偏移量的值。
#include //offsetof的头文件 struct S1 { char c1; int i; char c2; }; struct S2 { char c1; char c2; int i; }; int main() { printf("%d\n", offsetof(struct S1, c1)); printf("%d\n", offsetof(struct S1, i)); printf("%d\n", offsetof(struct S1, c2)); printf("\n"); printf("%d\n", offsetof(struct S2, c1)); printf("%d\n", offsetof(struct S2, c2)); printf("%d\n", offsetof(struct S2, i)); return 0; } //结果: 0 4 8 0 1 41.6.1：为什么存在内存对齐？
- 平台原因（移植原因）：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
- 性能原因：
数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。
结构体的内存对齐是拿空间来换取时间的做法
在设计结构体的时候如何实现节省空间呢？
让占用空间小的成员尽量集中在一起。
1.7：修改默认对齐数：
通过#pragma pack()来设置默认对齐数
实际应用：
//修改默认对齐数 #pragma pack(1)//把默认对齐数设置成4 struct S1// { char c1; int i; char c2; }; #pragma pack()//恢复默认对齐数，恢复成原来的8 int main() { printf("%d\n", sizeof(struct S1)); return 0; } //结果： 6为什么是6呢？
因为此时的对齐数被修改成了1，此时对于结构体成员中的i来说，它的自身大小是4个字节，当前的默认对齐数是1，取两者的较小值，也就是1，此时i变量在内存中的地址就可以从偏移量是1的地方开始，因此最终这个结构体类型的大小变成了6个字节。可见如果把默认对齐数修改成1，那么就不存在内存对齐了，所有的结构体成员变量在内存中都是紧挨着放的。
1.8：结构体传参：
//结构体传参 struct S { int data[4]; int num; }; //直接传结构体变量 void print1(struct S s)//实参传的是一个结构体变量，所以形参用一个对应的结构体变量来接收 { int i = 0; for (i = 0; i data[i]); } printf("%d\n", ps->num); } int main() { struct S s = { {1,2,3,4}, 1000 }; print1(s); //传结构体 print2(&s); //传地址 return 0; }上面展示了两种结构体传参的方法，分别是传结构体变量和传结构体的地址，对于这两种传参的方法在使用的时候该如何抉择呢？
答案是：首选传结构体的地址。原因在于，函数传参的时候是需要压栈的，会有时间和空间上的系统开销。如果传递一个较大的结构体变量，参数压栈的系统开销就会比较大，这样就会导致性能的下降。
二：位段
2.1：什么是位段？
位段的声明和结构体的声明是比较类似的，但是有以下两个不同点：
- 位段的成员必须是int、unsigned int、signed int等整型家族的类型。（大部分平台也支持char类型。一个位段的所有成员类型一般都是相同的）
- 位段的成员名后边有一个冒号和一个数字
例如：
struct A { int _a : 2; int _b : 5; int _c : 10; int _d : 30; }; //这里的A就是一个位段类型 int main() { printf("%d\n", sizeof(struct A)); return 0; }上面代码中的struct A就是一个位段类型，但是当我们计算这个位段类型的大小时，得到的结果是8。这是为什么呢？按照我们一般的想法：一个int型的大小是4个字节，这里一共有四个int型，所以这个类型的大小应该是16个字节才对。那这里的8到底是怎么得来的呢？这就要利用接下来要介绍的知识“位段的内存分配”来解释了。
2.2：位段的内存分配
首先我们需要知道，位段中的"位"指的是二进制位。int _a : 2;表示给_a变量分配2个bit位（）；int _b : 5;表示给_b变量分配5个bit位，以此类推：给_c变量分配10个bit位，给_d变量分配30个bit位。
结构体能干什么位段就能干什么，位段只是比结构体更节省空间而已。
- 位段的成员可以是 int unsigned int signed int 或者是 char （属于整形家族）类型
- 位段的空间上是按照需要以4个字节（int）或者1个字节（char）的方式来开辟的
- 位段设计很多不确定因素，位段是不跨平台，注重可移植的程序应该避免使用位段
以上面代码中的struct A类型的位段为例，探究其在内存中的分配
struct A的位段成员都是int型，所以会按照4个字节来开辟空间，首先开辟第一个4字节的空间（32bit），_a占用其中的两个bit位，_b占用里面的五个bit位，_c占用里面的十个bit位，此时，第一次开辟的4个字节（32bit）只剩下15bit了，而_d需要30bit，因此空间不够，需要再开辟第二个4字节空间（32bit），所以struct A这个类型的大小就是8个字节（64个bit位）。但此时就遇到一个比较尴尬的问题，_d到底会不会利用前面剩下的15个bit位呢？这个并没有定论，C语言标准也没有对此做出任何规定，不同的编译器可能会有不同的处理方法。
注意：位段成员后面的数字不得超过它自身本来的大小，例如位段成员如果是int型，那么它后面的数字就不得超过32，因为一个int型的变量它本来的大小是4个字节，就是32位bit。（这里针对的是32位机和64位机，早期的16位机，一个int型的大小是16个字节）
2.3：验证vs2019上位段的内存分配和使用
通过调用内存调试窗口。我们发现再在vs2019这个编译器上，对于前面剩下的字节，下一个位段成员是没有再利用的。
2.4：位段的跨平台问题
- int位段被当成有符号数还是无符号数是不确定的
- 位段中最大位的数目不能确定。（比如 int 型在16位机器中最大只有16bit，在32和64位机器上最大有64bit）
- 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义
- 当一个结构体包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的 bit 位时，是舍弃剩余的位还是利用，这也是不确定的
2.5：位段的应用
位段会被应用在网络数据传输中，它可以有效缓解网络“拥堵”。
总结：
今天，我们从结构体的一般声明开始，了解了一种特殊的声明（匿名结构体），学习了结构体变量的定义和初始化，探究了结构体的内存对齐，并介绍了修改默认对齐数方法，最后介绍了一种特殊的结构体——位段，它的最大优点是比普通的结构体更加节省空间。
以上的内容如果对你有帮助的话，可以动动小手点赞、评论、收藏，你的支持就是我前进路上最大的动力！
- 平台原因（移植原因）：
