• C语言——结构体(位段)、联合体、枚举


    hello,大家好!我是柚子,今天给大家分享的内容是C语言中的自定义类型结构体、联合体以及枚举,有什么疑问或建议可以在评论区留言,会顺评论区回访哦~

    一、结构体 struct

    a.结构体声明

    不同于数组的是,结构体中的每个成员可以是不同类型的变量;而数组是一组相同元素的集合。(一)结构的声明

    例如:

    1. //结构体声明
    2. struct Str
    3. {
    4. char name[20];
    5. char sex[20];
    6. int num;
    7. int age;
    8. };//注意分号不能丢!!!

    (二)结构体变量的创建和初始化

    1. #include
    2. //结构体声明
    3. struct Str
    4. {
    5. char name[20];
    6. char sex[20];
    7. int num;
    8. int age;
    9. };//注意分号不能丢!!!
    10. int main()
    11. {
    12. struct Str s = { "丁鸣","女",2024001,18 }; //注意成员的顺序,不要乱!
    13. printf("name:%s\n", s.name);
    14. printf("sex:%s\n", s.sex);
    15. printf("num:%d\n", s.num);
    16. printf("age:%d\n", s.age);
    17. return 0;
    18. }

    (三)结构体的特殊声明

     先看代码:

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

     上述两种结构体在声明的时候省略了结构体标签,那如果将第一个结构体s的地址直接给p,能不能行的通呢??

    1. //匿名结构体
    2. struct
    3. {
    4. int a;
    5. int b;
    6. int c;
    7. }s;
    8. struct
    9. {
    10. int a;
    11. int b;
    12. int c;
    13. }*p;
    14. int mian()
    15. {
    16. p = &s;//是否合法?
    17. return 0;
    18. }

     如果你将代码放在VS上你就会发现它会直接报错;第一,编译器会把上边两个声明当成完全不同的两个类型,所以是非法的;第二,匿名结构体类型,如果没有对结构体类型重命名的话,基本上只能用一次。

    (四)结构体的自引用

    在结构体中包含一个类型为该结构体本身行不行???

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

    如果可以的话,那么sizeof(struct Node)的大小为多少呢?所以,这么写是错误的。

    为什么?

    因为一个结构体中再包含一个同类型的结构体变量,这样的话结构体变量的大小就会无穷大,是不合理的。

    正确的自引用方式如下:

    1. //正确的自引用
    2. struct Node
    3. {
    4. int data;
    5. struct Node* next;//存放节点地址
    6. };

     我们再来看一段代码:

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

    这样的代码是否可行?

    当然是大错特错啦,你这个Node命名还没完成,你就提前开始使用,肯定是错的。

    正确的应该这么用:

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

    b.结构体内存对齐

    (一)对齐原则:
    1.结构体的第一个成员对齐到和结构体变量起始位置偏移量为0的地址处

    2.其他成员变量要对齐到某个数字(对齐数)的整数倍的地址处。

       对齐数=编译器默认的一个对齐数与该成员变量大小的较小值

    -Vs中默认的值为8 
    -Linux中gcc没有默认对齐数,对齐数就是成员自身的大小

    3.结构体总大小为最大对齐数(结构体中每个成员变量都有一个对齐数,所有对齐数中最大的)整数倍

    4.如果嵌套了结构体的情况,嵌套的结构体成员对齐到自己的成员中最大对齐数的整数倍结构体的整体大小就是所有最大对齐数(含嵌套结构体中成员的对齐数)的整数倍

    (二)为什么存在内存对齐?

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

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

    假设一个处理器总是从内存中取8个字节,则地址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对齐成8倍数,那么就可以用一个内存操作来读或者写值了。否则,我们可能需要执行两次内存访问,因为对象可能被分放在两个8字节内存块中。

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

    所以,为了让我们既满足对齐,又满足节省空间,我们要尽可能的让占用空间小的成员集中在一起         

    (三) 修改默认对齐数

     #pragma 这个预处理指令,可以改变编译器的默认对齐数。

    1. //#pragma
    2. #pragma pack(1) //设置默认对齐数1、4、8....
    3. struct s
    4. {
    5. char c1;
    6. int i;
    7. char c2;
    8. };
    9. #pragma pack() //取消默认对齐数
    10. int main()
    11. {
    12. printf("%d\n", sizeof(s));
    13. return 0;
    14. }

    (四)结构体传参

    1. //结构体传参
    2. struct S
    3. {
    4. int data[1000];
    5. int num;
    6. };
    7. //①
    8. void print1(struct S t)
    9. {
    10. printf("%d %d\n", t.data[3], t.num);
    11. }
    12. //②
    13. void print2(const struct S* pt)
    14. {
    15. printf("%d %d\n", pt->data[3], pt->num);
    16. }
    17. int main()
    18. {
    19. struct S s = { {1,2,3,4,5,6},10};
    20. print1(s);
    21. print2(&s);
    22. return 0;
    23. }

    一般我们选择第二种方法print2传参,不管是在空间上还是在性能上都是比较好的选择!!但是为了安全起见还是会加上const。

    原因:函数传参的时候,参数时需要压栈的,会有时间和空间上的系统开销。

               如果传递一个过大的结构体变量,参数压栈的系统开销较大导致性能下降。

    结论:结构体传参的时候,要传结构体的地址。

    (五)结构体实现位段

    什么是位段?(位表示:二进制位)

    位段是基于结构体的

    位段的声明和结构是类似的,有两个不同
    1.位段的成员必须是int、unsigned int 或signed int,在C99中位段成员的类型也可以选择其他类型。

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

    1. //位段
    2. struct A
    3. {
    4. int a : 2;
    5. int b : 5;
    6. int c : 10;
    7. int d : 30; //一共47个比特位,两个int型
    8. };
    9. int main()
    10. {
    11. printf("%d\n", sizeof(A)); //8
    12. return 0;
    13. }

    位段的出现其实就是为了节省空间的。

    位段的内存分配:

    1.位段的成员可以是int、unsigned int、signed int或者是char等类型

    2.位段的空间上是按照需要以4个字节(int)或者1个字节((char)的方式来开辟的。

    3.位段涉及很多不确定因素,位段是不可跨平台的,注重可移植性的程序应该避免使用位段。

    c.结构体变量的定义和初始化

    二、结构成员访问操作符

    结构体成员依据结构体变量类型的不同,一般有2种访问方式,一种为直接访问,一种为间接访问,相同的成员名称依靠不同的变量前缀区分。

    a.结构体成员的直接访问

    直接访问应用于普通的结构体变量,直接访问使用结构体变量名.成员名

    b.结构体成员的间接访问

    间接访问应用于指向结构体变量的指针,间接访问使用(*结构体指针名).成员名或者使用结构体指针名->成员名

    三、联合体(共用体)union

    a.联合体类型的声明

    1. //联合体
    2. union u
    3. {
    4. char c;
    5. int u;
    6. };
    7. int main()
    8. {
    9. union u uu;
    10. printf("%zd\n", sizeof(uu));
    11. printf("%zd\n", &uu);
    12. printf("%zd\n", &(uu.c));
    13. printf("%zd\n", &(uu.u));
    14. return 0;
    15. }

    联合体的成员共用一块空间 ,两个成员不同时使用。

    b.联合体的特点

    联合的成员是共用同一块内存空间的,这样一个联合变量的大小,至少是最大成员的大小。

    c.联合体大小的计算

    联合提的大小至少是最大成员的大小。(X)

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

    1. //计算
    2. union U
    3. {
    4. char c[5]; //5
    5. //按数组中的元素来算:1 8 1
    6. int a; //4
    7. //4 8 4
    8. };
    9. int main()
    10. {
    11. printf("%zd\n", sizeof(union U)); //8
    12. return 0;
    13. }

    联合体也是存在对齐的。 

    d.相同成员的结构体和联合体的对比

    e.联合体的应用:

    使用联合体是可以节省空间的,比如,我们要搞一个活动,要上线一个礼品兑换单,礼品兑换单中有三种商品 : 图书、杯子、衬衫。

    每一种商品都有:库存量、价格、商品类型和商品类型相关的其他信息。

    图书:书名、作者、页数
    杯子:设计
    衬衫:设计、可选颜色、可选尺寸

    1. struct gift_1ist
    2. {
    3. //库存量、价格、商品类型
    4. int stock_num;
    5. double price;
    6. int item_type;
    7. union {
    8. //图书:书名、作者、页数
    9. struct
    10. {
    11. char title[20];
    12. char author[20];
    13. int num_pages;
    14. }book;
    15. //杯子:设计
    16. struct
    17. {
    18. char design[30];
    19. }mug;
    20. //衬衫:设计、可选颜色、可选尺寸
    21. struct
    22. {
    23. char design[30];
    24. int color;
    25. int sizes;
    26. }shirt;
    27. }item;
    28. };

    举例二: 

    1. union U
    2. {
    3. int n;//4
    4. struct S
    5. {
    6. char c1;
    7. char c2;
    8. char c3;
    9. char c4;
    10. }s;//4
    11. };
    12. int main()
    13. {
    14. union U u = { 0 };
    15. u.n = 0x11223344;
    16. //拿出每个字节里的内容,巧妙利用联合体成员占用同一个空间
    17. printf("%x %x %x %x\n", u.s.c1, u.s.c2, u.s.c3, u.s.c4);
    18. return 0;
    19. }

    四、枚举 enum

    a.枚举类型的声明

    枚举就是可以一一例举,把可能的取值一一列举。

    1. //枚举 enum
    2. enum Sex
    3. {
    4. //性别
    5. MALE,
    6. FEMALE,
    7. SECRET
    8. };
    9. int main()
    10. {
    11. printf("%d\n", MALE);
    12. printf("%d\n", FEMALE);
    13. printf("%d\n", SECRET);
    14. return 0;
    15. }

    b.枚举类型的优点

    我们可以使用#define定义常量,为什么非要使用枚举?
    枚举的优点: 
    1.增加代码的可读性和可维护性 

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

    3.便于调试,预处理阶段会删除#define定义的符号

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

    5.枚举常量是遵循作用域规则的,枚举声明在函数内,只能在函数内使用

    今天的分享就先到这里,我们下期不见不散!!!拜拜~

  • 相关阅读:
    Html_Css问答集(4)
    JS,DOM试题1,在实践中应用,非常详细!!
    如何在S32K144中优雅地输出调试信息
    个性化定义多个 Git 托管平台配置
    代码随想录算法训练营第一天(C)| 704. 二分查找 27. 移除元素
    TCL基础入门
    除了走路,40-60岁的人,还可以进行哪些运动?3种运动可供参考
    【CodeTop】20. 有效的括号
    【Python数据分析工具】
    Wordpress 如何添加 Ads.txt 文件
  • 原文地址:https://blog.csdn.net/2301_77529159/article/details/136288539