devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【C语言基础入门】9.C语言中的自定义数据类型_任意类型的数据在c语言中怎么表示

作者：繁依Fanyi0 | 2024-05-01 12:53:45

赞

踩

任意类型的数据在c语言中怎么表示

文章目录

一、自定义数据类型（上）

二、自定义数据类型（中）​​​​​

三、自定义数据类型（下）​​​​​

一、自定义数据类型（上）

  • 类型命名关键字 (typedef) 
    • C语言中可以对类型赋予新名字
    • 语法：typedef Type New TypeName;
      • 注意：typedef 并没有创建新类型，只是创建了类型别名
  • 深入 typedef 应用
    • typedef 可在函数中定义“局部类型名”
    • typedef 常用于简化类型名(如: unsigned long long)
    • typedef 定义类型名，能够以统一的方式创建变量(Type var; )

        下面看一段代码：

  1. #include <stdio.h>
  2.  
  3. typedef  unsigned char  byte;
  4.  
  5. void func()
  6. {
  7.     typedef  byte  uint8;
  8.  
  9.     uint8 var = 200;
  10.     byte  b   = var;   // 本质为相同类型变量之间的初始化
  11.  
  12.     printf("sizeof(uint8) = %d\n", sizeof(uint8));
  13.     printf("var = %d\n", var);
  14.     printf("b = %d\n", b);
  15. }
  16.  
  17. int main()
  18. {
  19.     // uint8 var = 1;   // ERROR
  20.     byte b = 128;
  21.  
  22.     func();
  23.  
  24.     printf("sizeof(byte) = %d\n", sizeof(byte));
  25.     printf("b = %d\n", b);
  26.  
  27.     return 0;
  28. }

​​​​​​        下面为输出结果：

​​​​        需要注意：本代码中的 byte 和 uint8 为同一个自定义类型，所以它们之间可以相互赋值。

         再来看一段代码：

  1. #include <stdio.h>
  2.  
  3. typedef  float(FArr5)[5];        // 定义数组类型名
  4. typedef  int(IFuncII)(int, int); // 定义函数类型名
  5.  
  6. typedef  FArr5*    PFArr5;
  7. typedef  IFuncII*  PIFuncII;
  8.  
  9. float g_arr[5] = {0.1, 0.2, 0.3};
  10.  
  11. int add(int a, int b)
  12. {
  13.     return a + b;
  14. }
  15.  
  16. int main()
  17. {
  18.     FArr5* pa = &g_arr;  // float(*)[5]
  19.     IFuncII* pf = add;   // int(*)(int,int)
  20.  
  21.     PFArr5   npa = pa;
  22.     PIFuncII npf = pf;
  23.  
  24.     int i = 0;
  25.  
  26.     for(i=0; i<5; i++)
  27.     {
  28.         printf("%f\n", (*pa)[i]);
  29.         printf("%f\n", (*npa)[i]);
  30.     }
  31.  
  32.  
  33.     printf("%d\n", pf(2, 3));
  34.     printf("%d\n", npf(2, 3));
  35.  
  36.     return 0;
  37. }

        下面为输出结果：

         这里要特别注意函数指针的用法，可以通过 typedef 使得函数指针的定义简化。

  •  C语言中的结构体（ struct )
    • ​​​​​​​struct 是C语言中的自定义类型关键字
    • struct 能够定义不同数据类型变量的集合类型

        语法：

        struct TypeName

        {

                Type1 var1;

                Type2 var2;

                ......;

                typeN varn;

        };

        下面看一段代码：

  1. #include <stdio.h>
  2. #include <string.h>
  3.  
  4. struct Student
  5. {
  6.     char name[20];
  7.     int id;
  8.     short major;
  9. };
  10.  
  11. int main()
  12. {
  13.     struct Student s1 = {"Autumn", 908, 1};
  14.     struct Student s2 = s1;
  15.  
  16.     printf("s1.name = %s\n", s1.name);
  17.     printf("s1.id = %d\n", s1.id);
  18.     printf("s1.major = %d\n", s1.major);
  19.  
  20.     strcpy(s2.name, "Hu");
  21.     s2.id = 909;
  22.     s2.major = 2;
  23.  
  24.     printf("s2.name = %s\n", s2.name);
  25.     printf("s2.id = %d\n", s2.id);
  26.     printf("s2.major = %d\n", s2.major);
  27.  
  28.     return 0;
  29. }

        下面为输出结果：

  •  小结
    • C语言中通过 typedef 关键字对数据类型赋予新名字
    • typedef 并不会创建一个全新的数据类型
    • struct 是C语言中的自定义类型关键字
    • struct 用于创建不同数据类型变量的集合类型

二、自定义数据类型（中）​​​​​

  •  深入 struct  结构体类型
    • ​​​​​​​struct 结构体变量的本质是变量的集合
    • struct 结构体变量中的成员占用独立的内存
    • struct 结构体类型可用 typedef 赋予新类型名
    • 可定义struct 结构体类型的指针，并指向对应类型的变量
    • struct 结构体类型可先前置声明，再具体定义
    • 前置类型声明只能用于指针定义
    • 类型完整定义之后才能进行变量定义
    • struct 结构体类型可以省略类型名
      • ​​​​​​​类型名省略时，每次创建变量必须给出完整结构体定义
    • ​​​​​​​struct 结构体类型可以省略类型名（无名结构体类型)
    • 类型名省略时，每次创建变量必须给出完整结构体定义
    • 无名结构体类型总是互不相同的类型（互不兼容)

        先看第1段代码：

  1. #include <stdio.h>
  2. #include <string.h>
  3.  
  4. typedef  struct Student  Stu;
  5.  
  6. struct Student
  7. {
  8.     char name[20];
  9.     int id;
  10.     short major;
  11. };
  12.  
  13. int main()
  14. {
  15.     Stu s;
  16.     Stu* ps = &s;
  17.  
  18.     strcpy(ps->name, "Autumn");
  19.  
  20.     ps->id = 1;
  21.     ps->major = 908;
  22.  
  23.     (*ps).major = 910;   // ==> s.major = 910
  24.  
  25.     printf("s.name = %s\n", s.name);
  26.     printf("s.id = %d\n", s.id);
  27.     printf("s.major = %d\n", s.major);
  28.  
  29.     return 0;
  30. }

        下面为输出结果：
 

         这里注意结构体变量指针通过 -> 操作符访问成员变量。

        再看第2段代码：

  1. #include <stdio.h>
  2. #include <string.h>
  3.  
  4. struct Test;
  5. struct Test* g_pt;    // 只要有了类型声明就可以创建对应的指针变量
  6.  
  7. // 必须先给出类型的完整定义才能创建相应类型的变量
  8. struct Test
  9. {
  10.     int a;
  11.     int b;
  12. };
  13.  
  14. int main()
  15. {
  16.     struct Test t;
  17.  
  18.     t.a = 1;
  19.     t.b = 2;
  20.  
  21.     g_pt = &t;
  22.  
  23.     printf("g_pt = %p\n", g_pt);
  24.     printf("g_pt->a = %d\n", g_pt->a);
  25.     printf("g_pt->b = %d\n", g_pt->b);
  26.  
  27.     return 0;
  28. }
  29.

         下面为输出结果：

 

 这里注意两个问题：

1.只要有了类型声明就可以创建对应的指针变量

2.必须先给出类型的完整定义才能创建相应类型的变量

         再看第3段代码：

  1. #include <stdio.h>
  2. #include <string.h>
  3.  
  4. int main()
  5. {
  6.     struct { int a, b; } v1;
  7.     struct { int a, b; } v2;
  8.     struct { int a, b; }*pv;
  9.  
  10.     v1.a = 1;
  11.     v1.b = 2;
  12.  
  13.     v2 = v1;
  14.  
  15.     pv = &v2;
  16.  
  17.     return 0;
  18. }
  19.

        这段代码编译会出错：

 这段代码充分说明无名结构体类型总是互不相同的类型（互不兼容)

  • 位域 
    • ​​​​​​​现代程序设计中，内存使用的最小单位为字节（约定俗成)
    • 在一些特定场合，可将比特位作为最小单位使用内存
    • 结构体类型能够指定成员变量占用内存的比特位宽度（位域)
  • 深入位域
    • ​​​​​​​位域成员必须是整型，默认情况下成员依次排列
    • 位域成员占用的位数不能超过类型宽度（错误示例: char c : 9; )
    • 当存储位不足时，自动启用新存储单元
    • 可以舍弃当前未使用的位，重新启用存储单元

         下面看一段代码：

  1. #include <stdio.h>
  2.  
  3. struct BW
  4. {
  5.     unsigned char a : 4;
  6.     unsigned char b : 2;
  7.     unsigned char c : 2;
  8. };
  9.  
  10. int main()
  11. {
  12.     struct BW bw = {0};
  13.  
  14.     bw.a = 10;
  15.     bw.b = 4;   // 4 大于 b 能表示的最大值，因此赋值后 b 回转到 0
  16.     bw.c = 3;
  17.  
  18.     printf("sizeof(struct BW) = %d\n", sizeof(struct BW));
  19.     printf("bw.a = %d\n", bw.a);
  20.     printf("bw.b = %d\n", bw.b);
  21.     printf("bw.c = %d\n", bw.c);
  22.  
  23.     return 0;
  24. }
  25.

        下面为输出结果：

         这里注意 a : 4 ，所以 a 的取值范围是 0000 ~ 1111 之间，即 0 ~ 15 之间。

        再看一段代码：

  1. #include <stdio.h>
  2. #include <string.h>
  3.  
  4. struct Bits1
  5. {
  6.  
  7.     int a   : 16;
  8.     short b : 8;
  9.     char c  : 8;
  10.     float f;     // float f : 32;   ==> 浮点型成员不能指点位宽度
  11. };
  12.  
  13. struct Bits2
  14. {
  15.     unsigned char a : 6;
  16.     unsigned char b : 6;
  17.     unsigned char c : 6;
  18.     // unsigned char d : 9;    ==> 指定的位宽度不能大于声明类型的位宽度
  19. };
  20.  
  21. struct Bits3
  22. {
  23.     unsigned char a : 4;
  24.     unsigned char   : 0;  // 重启一个存储单元表示新的成员
  25.     unsigned char b : 4;
  26. };
  27.  
  28. int main()
  29. {
  30.     printf("sizeof(Bits1) = %d\n", sizeof(struct Bits1));
  31.     printf("sizeof(Bits2) = %d\n", sizeof(struct Bits2));
  32.     printf("sizeof(Bits3) = %d\n", sizeof(struct Bits3));
  33.  
  34.     return 0;
  35. }

         下面为输出结果：

         这里注意三点：

1.浮点型成员不能指点位宽度

2.指定的位宽度不能大于声明类型的位宽度

3.unsigned char  : 0 重启一个存储单元表示新的成员

  • 小结 
    • ​​​​​​​struct 结构体变量中的成员占用独立的内存
    • struct 结构体类型可用 typedef 赋予新类型名
    • 结构体类型能够指定成员变量占用内存的比特位宽度
    • 位域成员必须是整型，占用的位数不能超过类型宽度
    • 当存储位不足时，自动启用新存储单元

三、自定义数据类型（下）​​​​​

  •  C语言中的联合体( union )
    • union 是C语言中的自定义类型关键字
    • union 是 struct 的兄弟关键字，用法上非常相似

        语法：

        union TypeName

        {

                Type1 var1;

                Type2 var2;

                //......

                TypeN varn;

        };

  • union 与 struct 的不同
    • union 类型所有成员共享同一段内存(所有成员起始地址相同)
    • union 类型的大小取决于成员的最大类型
    • union 类型的变量只能以第一个 成员类型的有效值进行初始化

        下面看一段代码：

 

  1. #include <stdio.h>
  2. #include <string.h>
  3.  
  4. union UTest
  5. {
  6.     int a;
  7.     float f;
  8. };
  9.  
  10. struct STest
  11. {
  12.     int a;
  13.     float f;
  14. };
  15.  
  16. int main()
  17. {
  18.     union UTest ut = {987654321};
  19.     struct STest st = {987654321, 0.1f};
  20.  
  21.     printf("union UTest size = %d\n", sizeof(union UTest));
  22.     printf("&ut.a = %p\n", &ut.a);
  23.     printf("&ut.f = %p\n", &ut.f);
  24.  
  25.     printf("struct STest size = %d\n", sizeof(struct STest));
  26.     printf("&st.a = %p\n", &st.a);
  27.     printf("&st.f = %p\n", &st.f);
  28.  
  29.     printf("ut.a = %d\n", ut.a);
  30.     printf("ut.f = %f\n", ut.f);
  31.  
  32.     ut.f = 987654321.0f;
  33.  
  34.     printf("ut.a = %d\n", ut.a);
  35.     printf("ut.f = %f\n", ut.f);
  36.  
  37.     return 0;
  38. }
  39.

        下面为输出结果：

         这里注意整型数据和浮点类型数据在内存中的表示方式不一样，所以在同一段内存，同是4个字节，按照整型的方式解释这4个字节的数据时是一种结果，按照浮点数类型解释这4个字节时就是另一种结果。

  •  union 类型的应用-判断系统大小端
    • ​​​​​​​小端系统：低位数据存储在低地址内存中
    • 大端系统：低位数据存储在高地址内存中

        例如，对于 unsigned ui = 1;

         下面看一段判断大小端的代码：

  1. #include <stdio.h>
  2.  
  3. int isLittleEndian()
  4. {
  5.     union
  6.     {
  7.         int i;
  8.         char a[4];
  9.     } test = {0};
  10.  
  11.     test.i = 1;
  12.  
  13.     return (test.a[0] == 1);
  14. }
  15.  
  16. int main()
  17. {
  18.     printf("System Endian: %d\n", isLittleEndian());
  19.  
  20.     return 0;
  21. }
  22.

        下面为输出结果：

         由代码可知，1 存在低位，所以我的电脑为小端系统。

  •  C语言中的枚举类型( enum )
    • ​​​​​​​enum 是C语言中的自定义类型关键字
    • enum 能够定义整型常量的集合类型

​​​​​​​        语法：

        enum TypeName

        {

                IntConst1,

                IntConst2,

                //......

                IntconstN

        };

  • 枚举类型( enum )注意事项
    • 第一个枚举常量的默认值为0
    • 后续常量的值在前一一个常量值的基础上加1
    • 可以任意对枚举常量指定整型值(只能指定整型值)

        例如：

         下面看一段代码，感受一下：

  1. #include <stdio.h>
  2. #include <string.h>
  3.  
  4. enum Day { MON = 1, TUE, WED, THU, FRI, SAT, SUN };
  5. enum Season { Spring, Summer = 3, Autumn, Winter = -1 };
  6.  
  7. enum { CONSTANT = 12345 };
  8.  
  9. int main()
  10. {
  11.     enum Day d = TUE;
  12.     enum Season s = Winter;
  13.  
  14.     int i = SUN;
  15.     int j = Autumn;
  16.  
  17.     printf("d = %d\n", d);   // 2
  18.     printf("s = %d\n", s);   // -1
  19.     printf("i = %d\n", i);   // 7
  20.     printf("j = %d\n", j);   // 4
  21.  
  22.     d = 0;
  23.     s = -2;
  24.  
  25.     printf("d = %d\n", d);
  26.     printf("s = %d\n", s);
  27.  
  28.     printf("sizeof(enum Day) = %d\n", sizeof(enum Day));
  29.     printf("sizeof(enum Season) = %d\n", sizeof(enum Season));
  30.  
  31.     printf("CONSTANT = %d\n", CONSTANT);
  32.  
  33.     // CONSTANT = 54321;
  34.  
  35.     return 0;
  36. }
  37.

        下面为输出结果：

         这段代码也说明了 enum 枚举类型的本质就是整型。

  • 小结
    • union 是 struct 的兄弟关键字，用法上非常相似
    • union 类型所有成员共享同一段内存
    • enum 能够定义整型常量的集合类型
    • enum 的本质是 int 类型，常用于整型常量定义
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/518939
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号