【C语言】自定义类型

阳光穿透心脏的1/2处 2024-03-17 20:12 211阅读 0赞

文章目录

  • 一、结构体
    • 1、结构体声明
    • 2、结构体的自引用
    • 3、结构体变量的定义及初始化
    • 4、结构体内存对齐
    • 5、结构体传参
  • 二、位段
    • 1、什么是位段
    • 2、位段的内存分配
  • 三、枚举
    • 1、枚举的定义
    • 2、枚举的优点
    • 3、枚举的使用
  • 四、联合(共用体)
    • 1、联合类型的定义
    • 2、联合的特点
    • 3、联合体大小的计算

一、结构体

1、结构体声明

一般声明

  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. }; //分号

特殊声明
匿名结构体类型(不完全的声明)

  1. struct
  2. {
  3. int a;
  4. char b;
  5. float c;
  6. }x;
  7. struct
  8. {
  9. int a;
  10. char b;
  11. float c;
  12. }a[20], *p;

编译器会将两个匿名结构体类型当作是两种不同的类型,对于以上代码p=&x;这种的语句是非法的

2、结构体的自引用

结构体中的成员可以为该结构体本身,需要是指针类型
正确的自引用方式为:

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

3、结构体变量的定义及初始化

声明类型的同时定义变量:

  1. struct Point
  2. {
  3. int x;
  4. int y;
  5. }p1;

先声明之后再定义:

  1. struct Point
  2. {
  3. int x;
  4. int y;
  5. };
  6. struct Point p2;

初始化:定义变量的同时赋初值

  1. struct Point
  2. {
  3. int x;
  4. int y;
  5. };
  6. struct Point p3 = {
  7. x, y};

结构体嵌套初始化:

  1. struct Node
  2. {
  3. int data;
  4. struct Point p;
  5. struct Node* next;
  6. }n1 = {
  7. 10, {
  8. 4,5}, NULL}; //结构体嵌套初始化
  9. struct Node n2 = {
  10. 20, {
  11. 5, 6}, NULL};//结构体嵌套初始化

4、结构体内存对齐

结构体内存对齐规则:

  1. 第一个成员在与结构体变量偏移量为0的地址处。
  2. 其他成员变量要对齐到某个数字(对齐数)的整数倍的地址处。
    对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值
  3. 结构体总大小为最大对齐数(每个成员变量都有一个对齐数)的整数倍。
  4. 如果嵌套了结构体的情况,嵌套的结构体对齐到自己的最大对齐数的整数倍处,结构体的整体大小就是所有最大对齐数(含嵌套结构体的对齐数)的整数倍。

下来由一个例子来了解:

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

在这里插入图片描述
可以看到两个结构体拥有相同的成员,因为顺序不同,所以结构体大小也不同
在这里插入图片描述
修改编译器默认对齐数:

  1. #pragma pack(8)//设置默认对齐数为8(可为其他值)
  2. #pragma pack()//取消设置的默认对齐数,还原为默认

5、结构体传参

  1. struct S
  2. {
  3. int data[1000];
  4. int num;
  5. };
  6. struct S s = {
  7. {
  8. 1,2,3,4}, 1000};
  9. //结构体传参
  10. void print1(struct S s)
  11. {
  12. printf("%d\n", s.num);
  13. }
  14. //结构体地址传参
  15. void print2(struct S* ps)
  16. {
  17. printf("%d\n", ps->num);
  18. }

结构体传参的时候,要传结构体的地址,传结构体地址优于传结构体
原因:

  • 函数传参的时候,参数是需要压栈,会有时间和空间上的系统开销。
  • 如果传递一个结构体对象的时候,结构体过大,参数压栈的的系统开销比较大,所以会导致性能的下降。

二、位段

1、什么是位段

位段的声明与结构体类似,有两点不同:

  1. 位段的成员必须是 int、unsigned int 或signed int 。
  2. 位段的成员名后边有一个冒号和一个数字。
    例如:

    struct S
    {

    char a:3;
    char b:4;
    char c:5;
    char d:4;
    };

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

2、位段的内存分配

  1. 位段的成员可以是 int unsigned int signed int 或者是 char (属于整形家族)类型
  2. 位段的空间上是按照需要以4个字节( int )或者1个字节( char )的方式来开辟的。
  3. 位段涉及很多不确定因素,位段是不跨平台的,注重可移植的程序应该避免使用位段。

    include

    struct S
    {

    1. char a : 3;
    2. char b : 4;
    3. char c : 5;
    4. char d : 4;

    };
    int main()
    {

    1. printf("%d\n", sizeof(struct S));
    2. return 0;

    }

在这里插入图片描述
在这里插入图片描述

三、枚举

1、枚举的定义

枚举顾名思义就是一一列举。把可能的取值一一列举。
比如我们现实生活中:性别、月份、季节等

例如:

  1. enum Day//星期
  2. {
  3. Mon,
  4. Tues,
  5. Wed,
  6. Thur,
  7. Fri,
  8. Sat,
  9. Sun
  10. };
  • { }中的内容是枚举类型的可能取值,也叫枚举常量 。
  • 这些可能取值都是有值的,默认从0开始,依次递增1,当然在声明枚举类型的时候也可以赋初值。

2、枚举的优点

  1. 增加代码的可读性和可维护性
  2. 和#define定义的标识符比较枚举有类型检查,更加严谨
  3. 便于调试
  4. 使用方便,一次可以定义多个常量

3、枚举的使用

  1. enum Day//星期
  2. {
  3. Mon=1,
  4. Tues=2,
  5. Wed=4,
  6. Thur=5,
  7. Fri=7,
  8. Sat=9,
  9. Sun=20
  10. };
  11. enum Day d = Mon;//只能拿枚举常量给枚举变量赋值,才不会出现类型的差异。

四、联合(共用体)

1、联合类型的定义

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

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

2、联合的特点

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

  1. #include <stdio.h>
  2. union Un
  3. {
  4. char c;
  5. int i;
  6. };
  7. int main()
  8. {
  9. union Un un = {
  10. 0 };
  11. printf("%p\n", &un);
  12. printf("%p\n", &(un.i));
  13. printf("%p\n", &(un.c));
  14. return 0;
  15. }

在这里插入图片描述

3、联合体大小的计算

  • 联合的大小至少是最大成员的大小。
  • 当最大成员大小不是最大对齐数的整数倍的时候,就要对齐到最大对齐数的整数倍。

    include

    union Un1
    {

    1. char c[5];//5 1 8 1
    2. int i;//4 8 4

    };

    union Un2
    {

    1. short c[7];//14 2 8 2
    2. int i;//4 4 8 4

    };

    int main()
    {

    1. printf("%d\n", sizeof(union Un1));//5+3 = 8
    2. printf("%d\n", sizeof(union Un2));//16
    3. return 0;

    }

在这里插入图片描述

发表评论

表情:
评论列表 (有 0 条评论,211人围观)

还没有评论,来说两句吧...

相关阅读

    相关 C语言-定义类型2

    枚举 enum 枚举类型 \{枚举值列表\}; 枚举就是把每一种可能的取值一一列举出来。 比如我们做的单项选择题,列举出来四种可能的选项,让我们选择最可能的那一项

    相关 C语言-定义类型3

    联合体 联合体的定义 联合体是一种特殊的自定义类型,这种类型定义的变量也包含着许多成员(类型可以不同),特点是这些成员共用着同一块内存空间。 例如:

    相关 C语言定义类型

    本篇章梳理了下三种自定义类型:结构体、枚举、联合 内容框架: 结构体: 基础、初始化、结构体成员的访问、结构体传参、结构的自引用、计算结构体大小(重点) 枚举:枚举类