16.1 结构变量

  1. 联合是具有不同类型的值的集合（1）
  2. 结构体变量的初始化
    1. 可以短于初始化，剩余的成员用 0 表示
  3. 对结构的操作
    1. . 操作符取值，点操作符的优先级位于最高级（3）
    2. 对结构体输入值（4）
    3. 可以对相同类型的结构体相互赋值（5）
  1. // 1
  2. // 定义仓库中零件信息的结构体 
  3. struct 
  4. {
  5.     // 编号 
  6.     int number;
  7.     // 名称 
  8.     char name[NAME_LEN+1];
  9.     // 现有数量 
  10.     int on_hand;
  11. } part1,part2;
  13. // 2
  14. // 定义仓库中零件信息的结构体，并初始化
  15. struct 
  16. {
  17.     // 编号 
  18.     int number;
  19.     // 名称 
  20.     char name[NAME_LEN+1];
  21.     // 现有数量 
  22.     int on_hand;
  23. } part1={528,"Disk drive",10},
  24.   part2 = {914,"Printer cable",5};
  27. // 3
  28. #include <stdio.h>
  30. // 定义仓库中零件信息的结构体 
  31. struct 
  32. {
  33.     // 编号 
  34.     int number;
  35.     // 名称 
  36.     char name[20];
  37.     // 现有数量 
  38.     int on_hand;
  39. } part1={528,"Disk drive",10},
  40.   part2 = {914,"Printer cable",5};
  42. int main()
  43. {
  44.     printf("打印出 part1 的 number 编号：%d\n",part1.number);
  45. }
  47. // 输出
  48. 打印出 part1 的 number 编号：528
  50. // 4
  51. #include <stdio.h>
  53. // 定义仓库中零件信息的结构体 
  54. struct 
  55. {
  56.     // 编号 
  57.     int number;
  58.     // 名称 
  59.     char name[20];
  60.     // 现有数量 
  61.     int on_hand;
  62. } part1={528,"Disk drive",10},
  63.   part2 = {914,"Printer cable",5};
  65. int main()
  66. {
  67.     printf("修改 part1 的 number 编号：") ; 
  68.     // 注意 scanf 中不能在 %d 后面加 /n 
  69.     scanf("%d",&part1.number);
  70.     printf("打印出 part1 的 number 编号：%d\n",part1.number);
  71. }
  72. // 输出
  73. 修改 part1 的 number 编号：615
  74. 打印出 part1 的 number 编号：615
  76. // 5
  77. #include <stdio.h>
  79. // 定义仓库中零件信息的结构体 
  80. struct 
  81. {
  82.     // 编号 
  83.     int number;
  84.     // 名称 
  85.     char name[20];
  86.     // 现有数量 
  87.     int on_hand;
  88. } part1={528,"Disk drive",10},
  89.   part2 = {914,"Printer cable",5};
  91. int main()
  92. {
  93.     part1 = part2;
  94.     printf("%d,%s,%d\n",part1.number,part1.name,part1.on_hand); 
  95. }
  97. // 输出
  98. // 914,Printer cable,5

1. 结构体变量在内存中的存储

如，上面的 part1
image.png

16.2 结构类型

  1. 不是在同一处定义的结构体变量，即使完全一致的结构，也被认为是不一样的结构（1）
  2. 结构体标记的声明：用于解决在替他地方声明结构体（2）
  3. 结构体使用 typedef 的方式
  4. 结构体作为参数（3）
  5. 结构体作为返回值（4）
  1. // 1
  2. #include <stdio.h>
  3. // 定义仓库中零件信息的结构体 
  4. struct 
  5. {
  6.     // 编号 
  7.     int number;
  8.     // 名称 
  9.     char name[20];
  10.     // 现有数量 
  11.     int on_hand;
  12. } part1={528,"Disk drive",10};
  14. struct 
  15. {
  16.     // 编号 
  17.     int number;
  18.     // 名称 
  19.     char name[20];
  20.     // 现有数量 
  21.     int on_hand;
  22. } part2 = {914,"Printer cable",5};
  24. int main()
  25. {
  26.     // 此处报错，因为不是在同一处一起定义的
  27.     part1 = part2;
  28. }
  31. // 2
  32. #include <stdio.h>
  33. // 定义仓库中零件信息的结构体 
  34. struct part
  35. {
  36.     // 编号 
  37.     int number;
  38.     // 名称 
  39.     char name[20];
  40.     // 现有数量 
  41.     int on_hand;
  42. } part3,part4; // 1. 可以在标记时同时声明变量 
  46. int main()
  47. {
  48.     // 2. 也可以单独声明变量 
  49.     struct part part1,part2;
  50.     struct part part5;
  52.     // 3. 这样在别处声明的同一类型的变量就可以相互赋值了 
  53.     part5 = part1; 
  54. }
  56. // 3
  57. #include <stdio.h>
  59. struct part
  60. {
  61.     int number;
  62.     char name[20]; 
  63.     int on_hand;
  64. } part1 = {512,"disk driver",100};  
  67. void print_part(struct part p);
  69. int main()
  70. {
  71.     print_part(part1);
  72. }
  74. void print_part(struct part p)
  75. {
  76.     printf("part number:%d\n",p.number);
  77.     printf("part name:%d\n",p.name);
  78.     printf("on hand:%d\n",p.on_hand);
  79. }
  80. // 输出
  81. part number:512
  82. part name:6487556
  83. on hand:100
  85. // 4
  86. #include <stdio.h>
  87. #include <string.h>
  89. struct part
  90. {
  91.     int number;
  92.     char name[20]; 
  93.     int on_hand;
  94. } part1;  
  97. struct part build_part(int number,const char *name,int on_hand);
  99. int main()
  100. {
  101.     part1 = build_part(528,"disk driver",10);
  102. }
  104. struct part build_part(int number,const char *name,int on_hand)
  105. {
  106.     struct part p;
  107.     p.number = number;
  108.     strcpy(p.name,name);
  109.     p.on_hand = on_hand;
  111.     return p;
  112. }

16.3 数组和结构的嵌套

  1. 结构体嵌套结构体（1）
  2. 结构数组（2）
    1. note：scanf 一个数组元素，如果格式是 &s[0]，前面需要加上 & 符号
    2. 结构数组的初始化（3）
  1. // 1
  2. #include <stdio.h>
  4. struct person
  5. {
  6.     int age;
  7.     char name[20];
  8. };
  10. struct student
  11. {
  12.     struct person sp;
  13.     int classes;
  14. };
  16. int main()
  17. {
  18.     struct student s1,s2;
  19.     printf("输入年龄：");
  20.     scanf("%d",&s1.sp.age);
  21.     printf("录入年龄:%d",s1.sp.age);    
  22. }
  23. // 输出
  24. 输入年龄：11
  25. 录入年龄:11
  27. // 2
  28. #include <stdio.h>
  30. struct person
  31. {
  32.     int age;
  33.     char name[20];
  34. };
  36. struct student
  37. {
  38.     struct person sp;
  39.     int classes;
  40. };
  42. int main()
  43. {
  44.     struct student s[5];
  45.     printf("输入年龄：");
  46.     scanf("%d",&s[0].sp.age);
  47.     printf("录入年龄:%d",s[0].sp.age);    
  48. }
  49. // 输入
  50. 输入年龄：12
  51. 录入年龄:12
  53. // 3
  54.     struct student s[2] = 
  55.     {
  56.      {{11,"lili"},106},
  57.      {{12,"zhangsan"},108}
  58.     };

16.4 联合

  1. 联合的成员共享同一存储空间，且每次只能存储一个成员
  2. 编译器只为联合中最大的成员分配足够的空间（1）
  3. 结构体的成员存储在不同的内存中，而联合体存储在同一内存区域，这将导致后赋值的成员覆盖先赋值的成员（2）
  4. 联合体的初始化只能用于赋值给第一个成员
  1. // 1
  2. #include <stdio.h>
  4. union
  5. {
  6.     int i;
  7.     float f;
  8. }u;
  11. int main()
  12. {
  13.     printf("%d",sizeof(u));
  14. }
  15. // 输出，输出的 float 的大小
  16. 4
  18. // 2
  19. #include <stdio.h>
  21. union
  22. {
  23.     int i;
  24.     float f;
  25. }u;
  28. int main()
  29. {
  30.     u.i = 1;
  31.     u.f = 1.2;
  32.     printf("%d,%f",u.i,u.f);
  33. }
  34. // 输出，可以看到 u.i 的值已经找不到了
  35. 1067030938,1.200000

16.5 枚举