C语言——布局体,位段,罗列和连合

目次
媒介
布局体
1寄义
2语法
3匿名布局体
4布局体自引用
5布局体的界说与初始化
6内存对齐
7修改对齐数
8布局体传参
位段
1寄义
2位段的内存分配
​编辑3位段的标题 
4位段的应用
罗列
1寄义
2界说
3罗列长处
4罗列使用
连合
1寄义
2界说
3特点
4盘算
通讯录

---

媒介

C语言的布局体知识学好了的话对背面学习C++类对象就简单许多了
布局体

1寄义

布局体是一些值的聚集，这些值称为成员变量；每个成员变量可以是差异范例的变量。
2语法

1. struct tag//类型名
2. {
3.     member-list;//成员变量
4. }variable-list;//可在此时定义出结构体类型的变量 它是全局变量

复制代码

如果我们用布局体来形貌一个门生：

1. struct Stu
2. {
3.     char name[20];//名字
4.     int age;//年龄
5.     char sex[5];//性别
6.     char id[20];//学号
7. }S1;//分号不能丢

复制代码

3匿名布局体

也就是布局体不完全声明

1. //匿名结构体类型
2. struct
3. {
4.         int a;
5.         char b;
6.         float c;
7. }x;

复制代码

匿名布局体省略了tag(布局体范例名)，而且它只能用一次(声明后立即界说，不能声明后界说)
能否用指针来吸收匿名布局体变量？
不能，编译器会以为这个两个范例（vs2019编都编不外，vs2022能编过！）

4布局体自引用

1. struct Node
2. {
3.         int data;
4.         struct Node next;
5. };
7. int main()
8. {
9.         printf("%d", sizeof(struct Node));
10.         return 0;
11. }

复制代码

上面这种引用行吗？

   编译器以为：你在内部界说了同一个布局体成员，那这个成员变量里又包罗了同一个布局体成员...这个巨细是

无穷大的
  以是正确的布局体自引用

1. struct Node
2. {
3.     int data;
4.     struct Node* next;
5. };

复制代码

这种在链表中用的最多
别的的自引用界说：

1. typedef struct Node
2. {
3.         int data;
4.         N* next;
5. }N;

复制代码

这种写法是错误的：布局体typedef之前内部并不知道

1. //正确写法
2. typedef struct Node
3. {
4.         int data;
5.         struct Node* next;
6. }N;

复制代码

5布局体的界说与初始化

1. struct Poin
2. {
3.         int x;
4.         int y;
5. }p1 = {1,2};//可以在这里初始化
7. struct stu
8. {
9.         int date;
10.         struct Poin p;
11. }s1;//全局变量
13. int main()
14. {
15.         struct stu s2 = { 100,{20,30} };//局部变量 按顺序初始化
16.         //struct stu s2 = { .p={20,30},.date=100 };//指定成员初始化
17.         printf("%d %d %d\n", s2.date, s2.p.x, s2.p.y);
18.         return 0;
19. }

复制代码

6内存对齐

盘算布局体的巨细：这个非常紧张的一个内容！！！
来看下面的一段代码： 

1. struct s1
2. {
3.         char a;
4.         int b;
5.         char c;
6. };
8. struct s2
9. {
10.         char a;
11.         char c;
12.         int b;
13. };
15. int main()
16. {
17.         printf("s1的大小:%d\n", sizeof(struct s1));
18.         printf("s2的大小:%d", sizeof(struct s2));
19.         return 0;
20. }

复制代码

   int是4字节，char是1字节，两个int和一个char加起来不是6字节吗？
  差异的布局体放着类似的变量，只是次序差异，为什么巨细不一样？
  先容一个宏：offsetof，用来查察布局体变量相对于内存的偏移位置

按照打印出来的内存偏移位置举行安排成员变量的放置

一共9个字节就能竣事了，偏偏还要在浪费3个字节，前面也浪费3个字节，为什么？                    这时我们来看看内存对齐的规则：
   1. 第一个成员在与布局体变量偏移量为0的地点处。
2. 其他成员变量要对齐到对齐数整数倍的地点处。
对齐数 = 编译器默认的一个对齐数 与 该成员巨细的较小值
在VS中默认的值为8 而gcc是没有默认对齐数的
3. 布局体总巨细为最大对齐数（每个成员变量盘算出来的对齐数的最大值）的整数倍。
4. 如果嵌套告终构体的环境，嵌套的布局体对齐到自己的最大对齐数的整数倍处
  

布局体嵌套的布局体巨细：

1. #include<stdio.h>
3. struct S3//总大小：16
4. {
5.         double d;//8 8 -> 8
6.         char c;  //1 8 -> 1
7.         int i;   //4 8 -> 4
8. };
9. struct S4
10. {
11.         char c1;     //1  8 -> 1
12.         struct S3 s3;//16 8 -> 8
13.         double d;    //8  8 -> 8
14. };
15. int main()
16. {
17.         printf("%d\n", sizeof(struct S4));
18.         return 0;
19. }

复制代码

那为什么存在内存对齐? 
   1. 平台缘故原由(移植缘故原由)：
大概硬件平台只能在某些地点处取某些特定范例的数据(否则硬件停止)；
2. 性能缘故原由：
为了访问未对齐的内存，处置处罚器须要作两次内存访问；而对齐的内存访问仅须要一次访问
  这本质上就是以空间换时间来进步服从！
  

那在筹划布局体时：既要省空间，又要进步服从：
只管让字节小的成员变量放在一起

1. #include<stdio.h>
3. struct s1
4. {
5.         char c1;
6.         int i;
7.         char c2;
8. };
10. struct s2
11. {
12.         char c1;
13.         char c2;
14.         int i;
15. };
17. int main()
18. {
19.         printf("%d %d", sizeof(struct s1), sizeof(struct s2));
20.         return 0;
21. }

复制代码

7修改对齐数

如果对应VS的默认对齐数不满意（最好不修改！），可以自己设定对齐数

1. #pragma pack(1)
2. //在#pragma的范围内的对齐数是1
3. struct s3
4. {
5.         char c1;
6.         int i;
7.         char c2;
8. };
9. #pragma()
11. struct s4
12. {
13.         char c1;
14.         int i;
15.         char c2;
16. };
18. int main()
19. {
20.         printf("s3=%d s4=%d", sizeof(struct s2), sizeof(struct s3));
21.         return 0;
22. }

复制代码

8布局体传参

1. struct S
2. {
3.         int data[1000];
4.         int num;
5. };
6. struct S s = { {1,2,3,4}, 1000 };
8. void print1(struct S s)
9. {
10.         printf("%d\n", s.num);
11. }
13. void print2(struct S* ps)
14. {
15.         printf("%d\n", ps->num);
16. }
18. int main()
19. {
20.         print1(s); //传结构体
21.         print2(&s); //传地址
22.         //那种方式更优点？
23.         return 0;
24. }

复制代码

  关于布局体传参，只管使用传址传参：
  由于一个布局体巨细大概很大，如果传值传参会加大体系资源的开销，导致性能的降落；而使用传址传参时数据不渴望举行修改，要把const加上！
  位段

1寄义

   位段是一种特别的自界说范例；
  对空间的使用精打细算
  a 位段的成员必须是 int、char(整形眷属)；
b 位段的成员名后边有一个冒号和一个数字

1. struct A
2. {
3.         int _a : 2;
4.         int _b : 5;
5.         int _c : 10;
6.         int _d : 30;
7. };

复制代码

与布局体相比巨细方面有什么差异吗？

1. struct A//如果是结构体
2. {
3.         int _a : 2;
4.         int _b : 5;
5.         int _c : 10;
6.         int _d : 30;
7. };
9. struct B
10. {
11.         int _a;
12.         int _b;
13.         int _c;
14.         int _d;
15. };
17. int main()
18. {
19.         printf("A=%d B=%d", sizeof(struct A),sizeof(struct B));
20.         return 0;
21. }

复制代码

答案：位段比布局体巨细要小，更节流空间了！那这是怎么实现的呢？
2位段的内存分配

   位段背面的数字代表要分配多少个bit空间给该成员；
  位段的空间是按照须要以4个字节（ int ）大概1个字节（ char ）的方式来开发的

1. #include<stdio.h>
3. struct S
4. {
5.         char a : 3;
6.         char b : 4;
7.         char c : 5;
8.         char d : 4;
9. };
11. int main()
12. {
13.         struct S s = { 0 };
14.         s.a = 10;
15.         s.b = 12;
16.         s.c = 3;
17.         s.d = 4;
18.         return 0;
19. }

复制代码

3位段的标题 

   1. int 位段被当成有符号数还是无符号数？
2. 位段中最大位的数量？
  （16位呆板最大16，32位呆板最大32，如果写成27，在16位呆板会出标题）
3. 位段中的成员在内存中从左向右分配，还是从右向左分配？
  （在VS时从右向左）
4. 开发的空间无法容纳下个位段时，是舍弃后别的开发空间还是使用？
  （在VS时舍弃剩余的位）
  4位段的应用

应用于各种协议（信息传到下一层时须要用到）

罗列

1寄义

罗列就是逐一枚举；在实际生存中把一个星期举行罗列：星期一，星期二，星期三...                    那么罗列怎么用代码来表现呢？
2界说

1. enum Day//星期
2. {
3.         Mon = 1,
4.         Tues,
5.         Wed,
6.         Thur,
7.         Fri,
8.         Sat,
9.         Sun
10. };

复制代码

  enum Day是一个罗列范例；
  罗列括号内的内容都是常量；
  罗列默认从0开始（与数组一样）；但你也可以自己修改(Mon = 1)
  3罗列长处

以上对于星期的罗列：我们也可以用#define Mon 1，#define Tues 2来表现，那是不是就说罗列就可以被更换了？
   a 使用罗列方便调试（而#define在调试前就被更换成常量）；
  b 罗列有范例查抄，更严谨写；
  b 使用罗列能增长代码的可读性与可维护性；
  c 罗列内界说变量不存在定名辩说（而#define大概有定名污染标题）
  4罗列使用

1. enum Color//颜色
2. {
3.     RED=1,
4.     GREEN=2,
5.     BLUE=4
6. };
7. int main()
8. {
9.     enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异
10.     return 0;
11. }

复制代码

连合

1寄义

连合也是一种特别的自界说范例；
这种范例界说的变量也包罗一系列的成员，这些成员公用同一块空间（以是连合也叫共用体）。
2界说

1. #include<stdio.h>
2. //联合类型的声明
3. union Un
4. {
5.         char c;
6.         int i;
7. };
8. int main()
9. {
10.         union Un un;
11.         printf("%d\n", sizeof(un));
12.         return 0;
13. }

复制代码

3特点

   a 由于连合范例共有内存空间，以是比别的的布局体而言节流空间；
  b 成员共有内存空间，以是界说变量时成员不能同时出现（后一个会改变前一个的数据）
  使用场景1：判断巨细端（之前通过地点方式访问判断）

1. #include<stdio.h>
2. int sys_call()
3. {
4.         //匿名联合
5.         union
6.         {
7.                 char c;
8.                 int i;
9.         }Un;
10.         Un.i = 1;
11.         // 01 00 00 00 还是 00 00 00 01
12.         //(c与i公用1字节的内存空间)
13.         return Un.c;
14. }
16. int main()
17. {
18.         if (sys_call())
19.         {
20.                 printf("小端\n");
21.         }
22.         else
23.         {
24.                 printf("大端\n");
25.         }
26.         return 0;
27. }

复制代码

使用场景2：筹划一个礼品清单 

1. struct git_list
2. {
3.         double price;
4.         char name[20];
5.         char author[20];
6.         int page;
7.         char form[20];
8.         double size;
9.         char flavour[20];
10.         char materials[20];
11. };
13. //利用联合体设计清晰且省空间
14. struct git_list
15. {
16.         double price;
17.         char name[20];
19.         union
20.         {
21.                 char author[20];
22.                 int page;
23.         }book;
25.         union
26.         {
27.                 char form[20];
28.                 double size;
29.         }mug;
31.         union
32.         {
33.                 char flavour[20];
34.                 char materials[20];
35.         }cooike;
36. };

复制代码

4盘算

   a 连合的巨细至少是最大成员的巨细；
b 当最大成员巨细不是最大对齐数的整数倍的时间，就要对齐到最大对齐数的整数倍；
  以是：连合巨细 != 最大成员巨细

1. #include<stdio.h>
3. union Un1
4. {
5.         char c[5];
6.         int i;
7. };
9. int main()
10. {
11.         printf("%d\n", sizeof(union Un1));
12.         return 0;
13. }

复制代码

你大概会由于巨细是5(char c[5]一共是5字节，比i 4字节大)，但实际上：

   最大是5没错，但它不是最大对齐数（max(char，int) = 4）的整数倍，举行要举行对齐
  通讯录

   实现一个通讯录，具备以下功能：
  1增长接洽人(名字，年事，性别，电话，地点)；
  2删除接洽人的信息；
  3查找接洽人的信息；
  4更改接洽人的信息；
  5打印通讯录；
  6对通讯录举行排序；

1. //Contact.h
2. #define _CRT_SECURE_NO_WARNINGS 1
3. #include<stdio.h>
4. #include<stdlib.h>
5. #include<string.h>
6. #include<assert.h>
8. #define Max_Size 100
9. #define Max_NameSize 20
10. #define Max_SexSize 5
11. #define Max_CallSize 20
12. #define Max_AddrSize 30
14. enum
15. {
16.         ext,
17.         add,
18.         del,
19.         check,
20.         modify,
21.         print,
22.         sort,
23. };
25. typedef struct Mess
26. {
27.         char name[Max_NameSize];
28.         int age;
29.         char sex[Max_SexSize];
30.         char call[Max_CallSize];
31.         char addr[Max_AddrSize];
32. }Mess;
34. typedef struct Contact
35. {
36.         int sz;
37.         Mess message[Max_Size];
38. }Contact;
40. void Add(Contact* con);
41. void Del(Contact* con);
42. void Check(const Contact* con);
43. void Modify(Contact* con);
44. void Print(const Contact* con);
45. void Sort(Contact* con);
47. //Contact.c
48. #include"contact.h"
50. void Add(Contact* con)
51. {
52.         assert(con);
53.         if (con->sz == Max_Size)
54.         {
55.                 printf("Contact Is Full\n");
56.                 return;
57.         }
59.         printf("Input Name:");
60.         gets(con->message[con->sz].name);
61.         //scanf("%s", &con->message[con->sz].name);
62.     printf("Input Age:");
63.         scanf("%d", &con->message[con->sz].age);//如果输入的是非法字符串?
64.         getchar();//清空缓冲区的'\n'
65.         printf("Input Sex:");
66.         gets(con->message[con->sz].sex);
67.         //scanf("%s", &con->message[con->sz].sex);
68.         printf("Input Call:");
69.         gets(con->message[con->sz].call);
70.         //scanf("%s", &con->message[con->sz].call);
71.         printf("Input Addr:");
72.         gets(con->message[con->sz].addr);
73.         //scanf("%s", &con->message[con->sz].addr);
74.         con->sz++;
76.         printf("Add Finish\n");
77. }
79. void Print(const Contact* con)
80. {
81.         assert(con);
82.         if (con->sz == 0)
83.         {
84.                 printf("Contact Is Empty\n");
85.                 return;
86.         }
87.         printf("%-20s %-5s %-5s %-11s %-30s\n", "name", "age", "sex", "call", "addr");
88.         for (int i = 0; i < con->sz; i++)
89.         {
90.                 printf("%-20s %-5d %-5s %-11s %-30s\n",
91.                         con->message[i].name, con->message[i].age,
92.                         con->message[i].sex,con->message[i].call,
93.                         con->message[i].addr);
94.         }
95. }
97. static int Find(const Contact* con,char Name[])
98. {
99.         for (int i = 0; i < con->sz; i++)
100.         {
101.                 if (strcmp(con->message[i].name,Name)==0)//用strcmp比
102.                 {
103.                         printf("Find Sucess\n");
104.                         return i;
105.                 }
106.         }
107.         printf("Find Error\n");
108.         return -1;
109. }
111. void Del(Contact* con)
112. {
113.         assert(con);
114.         char InputName[Max_NameSize];
115.         printf("Input Del Name:");
116.         gets(InputName);
117.         int DelPos = Find(con, InputName);
118.         if (DelPos == -1) return;
119.         for (int i = DelPos; i < con->sz - 1; i++)
120.         {
121.                 con->message[i] = con->message[i + 1];//后一个往前一个覆盖
122.         }
123.         con->sz--;
124.         printf("Del Sucess\n");
126. }
128. void Check(const Contact* con)
129. {
130.         assert(con);
131.         printf("Input Check Name:");
132.         char Check_Name[Max_NameSize];
133.         gets(Check_Name);
134.         int pos = Find(con, Check_Name);
135.         if (pos == -1) return;
136.         printf("Check Result:\n");
137.         printf("%-20s %-5s %-5s %-11s %-30s\n", "name", "age", "sex", "call", "addr");
138.         printf("%-20s %-5d %-5s %-11s %-30s\n",
139.                 con->message[pos].name, con->message[pos].age,
140.                 con->message[pos].sex, con->message[pos].call,
141.                 con->message[pos].addr);
142. }
144. void Modify(Contact* con)
145. {
146.         assert(con);
147.         char Modify_Name[Max_NameSize];
148.         printf("Input Modify Name:");
149.         gets(Modify_Name);
150.         int pos = Find(con, Modify_Name);
151.         if (pos == -1) return;
153.         printf("Modify Name:");
154.         gets(con->message[pos].name);
155.         printf("Input Modify Age:");
156.         scanf("%d", &con->message[pos].age);
157.         getchar();
158.         printf("Input Modify Sex:");
159.         gets(con->message[pos].sex);
160.         printf("Input Modify call:");
161.         gets(con->message[pos].call);
162.         printf("Input Modify addr:");
163.         gets(con->message[pos].addr);
164.         printf("Modify Sucess\n");
165. }
167. int cmp(const void* a, const void* b)
168. {
169.         return ((*((Contact*)a)).message->age - (*((Contact*)b)).message->age);
170. }
172. void Sort(Contact* con)
173. {
174.         qsort(con, con->sz, sizeof(con->message[0]), cmp);
175.         printf("排序完成\n");
176. }
178. //test.c
179. #include"contact.h"
181. void memu()
182. {
183.         printf("********************************\n");
184.         printf("*****   0.exit    1.add    *****\n");
185.         printf("*****   2.del     3.check  *****\n");
186.         printf("*****   4.modify  5.print  *****\n");
187.         printf("*****         6sort        *****\n");
188. }
190. int main()
191. {
192.         Contact con;
193.         //对con空间进行清理
194.         memset(&con, 0, sizeof(con));
195.         int input;
196.         do
197.         {
198.                 memu();
199.                 printf("Please Select:");
200.                 //防止读到字符串时发生死循环
201.                 input = 123456;//防止下一次输入的是字符后input还是上一次的值
202.                 scanf("%d", &input);
203.                 getchar();//输入字符串时:清空缓冲区的'\n'
205.                 switch (input)
206.                 {
207.                 case ext:
208.                         printf("Process Exit");
209.                         break;
210.                 case add:
211.                         Add(&con);
212.                         break;
213.                 case del:
214.                         Del(&con);
215.                         break;
216.                 case check:
217.                         Check(&con);
218.                         break;
219.                 case modify:
220.                         Modify(&con);
221.                         break;
222.                 case print:
223.                         Print(&con);
224.                         break;
225.                 case sort:
226.                         Sort(&con);
227.                         break;
228.                 default:
229.                         printf("Select Error,Please Try Again\n");
230.                         break;
231.                 }
232.         }while(input);
234.         return 0;
235. }

复制代码

  但上面的通讯录无法做到：
  通讯录满了无法再存信息(学习动态内存管理后办理)；
  关闭步调时通讯录信息还存在(学习完文件利用后办理)；
    以上便是全部内容，有标题接待在批评区指正，感谢观看！