• C语言进阶:结构体，枚举，联合(结尾有彩蛋)

    目录

    结构体

    1.1 结构的声明

    1.2 特殊的声明

    1.3 结构的自引用

    1.4 结构体内存对齐

    1.5 修改默认对齐数

    2.1 位段

    2.2 位段的内存分配

    2.3 位段的跨平台问题

    总结

    2.4 位段的应用

    枚举

    3.1 枚举类型的定义

    枚举类型的取值

    3.2 枚举的优点

    3.3 枚举的使用

    联合

    4.1 联合类型的定义

    4.2 联合的特点

    4.3 联合大小的计算

    彩蛋

    结构体

    1.1 结构的声明

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

    描述一个学生

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

     

    1.2 特殊的声明

    在声明结构的时候，可以不完全的声明。 比如：

    1. //匿名结构体类型
    2. struct
    3. {
    4.  int a;
    5.  char b;
    6.  float c;
    7. }x;
    8. struct
    9. {
    10.  int a;
    11.  char b;
    12.  float c;
    13. }a[20], *p;

    两个结构体变量相同,那么p = &x;是否合法  

    答案是不合法的  虽然变量完全相同 但是编译器会把上面的两个声明当成完全不同的两个类型

    1.3 结构的自引用

    1. struct Node
    2. {
    3.  int data;  //数据域
    4.  struct Node* next; //指针域
    5. };

    注：typedef不能与匿名结构体类型一起使用 

    typedef是给已经存在的类型名进行换名

    1. //错误用法
    2. typedef struct
    3. {
    4.  int data;
    5.  Node* next;
    6. }Node;
    7.  
    8.  
    9. //解决方案：
    10. typedef struct Node
    11. {
    12.  int data;
    13.  struct Node* next;
    14. }Node;

    1.4 结构体内存对齐

    为什么存在内存对齐?

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

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

     

    结构体的对齐规则

    总的来说,结构体的内存对齐是拿空间来换取时间的做法。

    在设计结构体的时候,我们可以让占用空间小的成员尽量集中在一起。

    1. //例如：
    2. struct S1
    3. {
    4.  char c1;
    5.  int i;
    6.  char c2;
    7. };
    8.  
    9.  
    10. struct S2
    11. {
    12.  char c1;
    13.  char c2;
    14.  int i;
    15. };

    S1和S2类型的成员一模一样，但是S1和S2所占空间的大小有了一些区别。

    1.5 修改默认对齐数

    1. #pragma pack(8)//设置默认对齐数为8
    2.  
    3. #pragma pack()//取消设置的默认对齐数，还原为默认

    2.1 位段

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

         

         1.位段的成员必须是 int、unsigned int 或signed int 。

         2.位段的成员名后边有一个冒号和一个数字

    比如：

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

    A就是一个位段类型。

    2.2 位段的内存分配

    将十进制数转换为二进制数根据位段存入(vs平台从右往左)  其他平台需另分析

    当内存空间不能存放下一个成员时 再开辟一块空间(例子中为char类型  故开辟8个比特位)

    最后用十六进制(0x)表示

    2.3 位段的跨平台问题

    1. int 位段被当成有符号数还是无符号数是不确定的。

    2. 位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机 器会出问题。

    3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。

    4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的

    总结

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

    2.4 位段的应用

    枚举

    3.1 枚举类型的定义

    1. enum Day//星期
    2. {
    3.  Mon,
    4.  Tues,
    5.  Wed,
    6.  Thur,
    7.  Fri,
    8.  Sat,
    9.  Sun
    10. };
    11. enum Sex//性别
    12. {
    13.  MALE,
    14.  FEMALE,
    15.  SECRET
    16. }；
    17. enum Color//颜色
    18. {
    19.  RED,
    20.  GREEN,
    21.  BLUE
    22. };

    枚举类型的取值

    这些可能取值都是有值的，默认从0开始，依次递增1，当然在声明枚举类型的时候也可以赋初值。

    1. enum Color//颜色
    2. {
    3.  RED=1,
    4.  GREEN=2,
    5.  BLUE=4
    6. };
    7.  
    8.  
    9.  
    10. enum Color2//颜色
    11. {
    12.  RED,
    13.  GREEN=25,
    14.  BLUE,
    15. };

    此时 Color2 中 BLUE为 26  由GREEN递增1得

    3.2 枚举的优点

    1. 增加代码的可读性和可维护性

    2. 和#define定义的标识符比较枚举有类型检查，更加严谨。

    3. 便于调试

    4. 使用方便，一次可以定义多个常量

    3.3 枚举的使用

    1. enum Color//颜色
    2. {
    3.  RED=1,
    4.  GREEN=2,
    5.  BLUE=4
    6. };
    7. enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。
    8. clr = 5;               //不同的平台有不同的结果

    联合

    4.1 联合类型的定义

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

    1. //联合类型的声明
    2. union Un
    3. {
    4.  char c;
    5.  int i;
    6. };
    7. //联合变量的定义
    8. union Un un;

    4.2 联合的特点

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

    根据联合的特点我们可以判断当前计算机的大小端存储

    1. //联合类型的声明
    2. union Un
    3. {
    4. 	char c;
    5. 	int i;
    6. };
    7.  
    8. int main()
    9. {
    10. 	union Un u = { 0 };
    11. 	u.i = 1;
    12. 	if (u.c == 1)
    13. 		printf("小端\n");
    14. 	else
    15. 		printf("大端\n");
    16.  
    17.  
    18. 	return 0;
    19. }
    20.

    4.3 联合大小的计算

    联合的大小至少是最大成员的大小。

    当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。

    1. union Un1
    2. {
    3.  char c[5];     // 1 * 5 = 5
    4.  int i;         // 4 
    5. };
    6.  
    7.  
    8. union Un2
    9. {
    10.  short c[7];    // 2 * 7 = 14
    11.  int i;         // 4
    12. };

    根据计算规则  Un1大小为8    Un2大小为16

    彩蛋

    1. /* 皮卡丘祝你天天开心 */
    2.     /*
    3.         quu..__
    4.          $$$b  `---.__
    5.           "$$b        `--.                          ___.---uuudP
    6.            `$$b           `.__.------.__     __.---'      $$$$"              .
    7.              "$b          -'            `-.-'            $$$"              .'|
    8.                ".                                       d$"             _.'  |
    9.                  `.   /                              ..."             .'     |
    10.                    `./                           ..::-'            _.'       |
    11.                     /                         .:::-'            .-'         .'
    12.                    :                          ::''\          _.'            |
    13.                   .' .-.             .-.           `.      .'               |
    14.                   : /'$$|           .@"$\           `.   .'              _.-'
    15.                  .'|$u$$|          |$$,$$|           |  <            _.-'
    16.                  | `:$$:'          :$$$$$:           `.  `.       .-'
    17.                  :                  `"--'             |    `-.     \
    18.                 :##.       ==             .###.       `.      `.    `\
    19.                 |##:                      :###:        |        >     >
    20.                 |#'     `..'`..'          `###'        x:      /     /
    21.                  \                                   xXX|     /    ./
    22.                   \                                xXXX'|    /   ./
    23.                   /`-.                                  `.  /   /
    24.                  :    `-  ...........,                   | /  .'
    25.                  |         ``:::::::'       .            |<    `.
    26.                  |             ```|           x| \ `.:``.
    27.                  |                         .'    /'   xXX|  `:`M`M':.
    28.                  |    |                    ;    /:' xXXX'|  -'MMMMM:'
    29.                  `.  .'                   :    /:'       |-'MMMM.-'
    30.                   |  |                   .'   /'        .'MMM.-'
    31.                   `'`'                   :  ,'          |MMM<
    32.                     |                     `'            |tbap\
    33.                      \                                  :MM.-'
    34.                       \                 |              .''
    35.                        \.               `.            /
    36.                         /     .:::::::.. :           /
    37.                        |     .:::::::::::`.         /
    38.                        |   .:::------------\       /
    39.                       /   .''               >::'  /
    40.                       `',:                 :    .'
    41.                                            `:.:'
  • 相关阅读:
    MAC MINI 2012安装Montery折腾笔记
    sqli-labs(3)
    web网页设计期末课程大作业：家乡旅游主题网站设计——河北8页HTML+CSS+JavaScript
    算法与数据结构【30天】集训营——B树的创建、查找、插入、删除总结的最佳解决方法（17）
    LeetCode-739-每日温度-单调栈
    转发与重定向的使用
    keil报错：main.c(99): error: #20: identifier “xxx“ is undefined
    #define 的神奇操作
    Java、泛型快速排序
    关于linux 下启动脚本那些事
  • 原文地址：https://blog.csdn.net/Jay_0824/article/details/132941767