结构体（struct）

为什么需要结构体

为了表示一些复杂的事物，而普通的基本类型无法满足实际要求。

什么叫结构体

把一些基本类型数据组合在一起，形成一个新的复合数据类型，这个叫结构体。

  1. #include <stdio.h>
  3. struct Student
  4. {
  5.     int age;
  6.     float score;
  7.     char sex;
  8. };
  10. int main(void)
  11. {
  12.     struct Student st = {80, 66.6, 'F'};    //struct Student为数据类型，
  13.                                                 //st为结构体变量
  14.     return 0;
  15. }

定义结构体的3种方式

  1. //第一种方式----推荐使用，只是定义了一个新的数据类型，方便定义多个变量
  2. struct Student
  3. {
  4.     int age;
  5.     float score;
  6.     char sex;
  7. };
  8. //第二种方式----过于精简，不能重复定义
  9. struct Student2
  10. {
  11.     int age;
  12.     float score;
  13.     char sex;
  14. }st2;
  15. //第三种方式----过于精简，不能重复定义
  16. struct
  17. {
  18.     int age;
  19.     float score;
  20.     char sex;
  21. }st3;

结构体变量的用法

赋值和初始化

  1. 第一种方式：定义结构体变量的同时，整体赋初值
  2. struct Student st = {10, 66.6, 'F'};
  4. 第二种方式：定义结构体变量后，对每个成员赋初值
  5. struct Student st;
  6. st.age = 10;
  7. st.score = 66.6;
  8. st.sex = 'F';

定义结构体指针变量并赋值

  1. 定义形式：
  2. struct 结构体名 *变量名;
  4. 赋值格式：
  5. struct 结构体名 *变量名 = &结构体变量;
  7. 例子：
  8. struct Student st = {10, 66.6, 'F'};
  9. //struct Student *pst = st;    //error
  10. struct Student *pst = &st;    //&符号不能少

取出结构体变量中的每个成员

  1. #include <stdio.h>
  3. struct Student
  4. {
  5.     int age;
  6.     float score;
  7.     char sex;
  8. };
  10. int main(void)
  11. {
  12.     struct Student st = {10, 33.3, 'F'};
  13.     struct Student* pst = &st;
  15.     //第一种取出方式
  16.     st.age = 20;    //结构体变量名.成员名
  17.     //第二种取出方式----（更常用）
  18.     pst->age = 33;    //指针变量名->成员名
  20.     return 0;
  21. }
  23. //Note: pst->age在计算机内部会被转换成(*pst).age，等价于st.age。

结构体变量和结构体指针变量作为函数参数传递的问题

当结构体变量作为函数的形参时：

  • 对结构体变量进行修改时，必须发送结构体变量的地址；
  • 对结构体变量进行打印输出时，可以发送结构体变量的地址（推荐使用，内存占用空间小，执行速度快），也可以发送变量名。

即：推荐使用结构体指针变量作为函数参数传递。

结构体变量的运算

结构体变量不能相互加减，也不能相互乘除，但可以相互赋值。

  1. 例子：
  3. struct Student
  4. {
  5.     int age;
  6.     char sex;
  7.     char name[100];
  8. };
  9. struct Student st1,st2;
  10. // st1+st2; st1-st2; st1*st2; st1/st2; //都是错误的
  11.  st1 = st2;    //正确

冒泡排序

  1. 1. 确定一个数组仅需要两个参数；
  2. 2. 冒泡排序的核心是先找最大值或最小值，下面代码是先找最大值。
  4. void sort(int* arr, int len)
  5. {
  6.     int i = j = temp = 0;
  7.     for(i = 0;i < len - 1;i++)    //比较总次数
  8.     {
  9.         for(j = 0;j < len - 1 - i;j++)    //两两比较
  10.         {
  11.             if(arr[j] > arr[j + 1])
  12.             {
  13.                 temp = arr[j];
  14.                 arr[j] = arr[j + 1];
  15.                 a[j + 1] = temp;
  16.             }
  17.         }
  18.     }
  19. }

动态构造存放学生信息的结构体数组

  1. /* 申请动态空间存入学生信息，并进行排序 */
  2. #include <stdio.h>
  3. #include <malloc.h>
  5. // 学生信息结构体
  6. struct Student
  7. {
  8.     int age;
  9.     float score;
  10.     char name[100];
  11. };
  13. // 学生信息录入
  14. void Info_input(struct Student *pArr)
  15. {
  16.     int len;
  17.     struct Student temp;
  18.     printf("请输入学生的个数：");
  19.     scanf("%d", &len);
  20.     pArr = (struct Student *)malloc(len * sizeof(struct Student));    //struct占用的内存空间大小为所有结构体成员的空间总和
  22.     // 信息录入
  23.     for (int i = 0; i < len; i++)
  24.     {
  25.         printf("请输入第%d个学生的信息：\n", i + 1);
  26.         printf("age = ");
  27.         scanf("%d", &pArr[i].age);
  29.         printf("name = ");
  30.         scanf("%s", pArr[i].name); //name是数组名，本身是数组的首地址，无需加“&”符号
  32.         printf("score = ");
  33.         scanf("%f", &pArr[i].score);
  34.     }
  35.     // 排序
  36.     for (int i = 0; i < len - 1; i++)
  37.     {
  38.         for (int j = 0; j < len - 1 - i; j++)
  39.         {
  40.             if (pArr[j].score > pArr[j + 1].score)
  41.             {
  42.                 temp = pArr[j];
  43.                 pArr[j] = pArr[j + 1];
  44.                 pArr[j + 1] = temp;
  45.             }
  46.         }
  47.     }
  48.     // 输出
  49.     for (int i = 0; i < len; i++)
  50.     {
  51.         printf("\n第%d各学生的信息是：\n", i + 1);
  52.         printf("age = %d\n", pArr[i].age);
  53.         printf("name = %s\n", pArr[i].name);
  54.         printf("age = %f\n", pArr[i].score);
  55.         printf("\n");
  56.     }
  57. }
  59. int main(void)
  60. {
  61.     struct Student *st = NULL;
  62.     Info_input(st);
  63.     free(st);
  64.     return 0;
  65. }

枚举（enum）

枚举的定义

把一个事物所有可能的取值一一列举出来。

  1. 定义形式：
  2. enum typeName{ valueName1, valueName2, valueName3, ...... };
  4. ----枚举值默认从0开始，往后逐个加1。初始化定义的时候，可以指定枚举值的数值，一般只定义第一个枚举值即可。
  6. 例子：
  7. enum week{ Mon, Tues, Wed, Thurs, Fri, Sat, Sun };

枚举的用法

  1. /* 查询星期缩写 */
  2. #include <stdio.h>
  4. enum week
  5. {
  6.     Mon = 1,
  7.     Tues,
  8.     Wedn,
  9.     Thurs,
  10.     Fri,
  11.     Sat,
  12.     Sun
  13. };
  15. int main(void)
  16. {
  17.     enum week day;
  18.     printf("请输入你要查询的星期缩写数值:");
  19.     scanf("%d",&day);
  20.     switch (day)
  21.     {
  22.     case Mon:
  23.         printf("这是Mon");
  24.         break;
  25.     case Tues:
  26.         printf("这是Tues");
  27.         break;
  28.     case Wedn:
  29.         printf("这是Wedn");
  30.         break;
  31.     case Thurs:
  32.         printf("这是Thurs");
  33.         break;
  34.     case Fri:
  35.         printf("这是Fri");
  36.         break;
  37.     case Sat:
  38.         printf("这是Sat");
  39.         break;
  40.     case Sun:
  41.         printf("这是Sun");
  42.         break;
  44.     default:
  45.         printf("error，请输入整型数值！");
  46.         break;
  47.     }
  48.     return 0;
  49. }

使用枚举的注意点

  • 枚举列表中的枚举值标识符的作用范围是全局的，不能再定义同样名字的变量；
  • 枚举值是常量，除了初始化定义时可以指定数值，其余情况下不可对其赋值；
  • 枚举和宏其实非常类似：宏在预处理阶段将名字替换成对应的值，枚举在编译阶段将名字替换成对应的值。我们可以将枚举理解为编译阶段的宏；
  • 枚举值不是变量，不占用内存空间，不能用**&**取枚举值的地址；

  • 枚举占用的内存空间仅为一个**int**整型的大小。

    枚举的优缺点

  • 优点：限定了取值的范围，使代码更安全；

  • 缺点：书写较为麻烦。

    共用体（union）

    共用体的定义形式

    1. union 共同体名
    2. {
    3.   成员列表1;
    4.   ...
    5.   成员列表n;
    6. };

    创建共同体的三种方式

    ```c // 第一种方式（推荐使用）——定义共同体后，创建共同体变量 union data { int n; char ch; double f; }; union data a, b, c;

// 第二种方式（过于精简，不能重复定义）——定义共同体的同时，创建共同体变量 union data { int n; char ch; double f; }a, b, c; // 第三种方式（过于精简，一次性使用）——不定义创建共同体变量 union { int n; char ch; double f; }a, b, c;

  1. <a name="zGKGf"></a>
  2. ## 共同体的内存存储分布
  3. ```c
  4. #include <stdio.h>
  5. union data{
  6.     int n;
  7.     char ch;
  8.     short m;
  9. };
  10. int main(){
  11.     union data a;
  12.     printf("%d, %d\n", sizeof(a), sizeof(union data) );
  13.     a.n = 0x40;
  14.     printf("%X, %c, %hX\n", a.n, a.ch, a.m);
  15.     a.ch = '9';
  16.     printf("%X, %c, %hX\n", a.n, a.ch, a.m);
  17.     a.m = 0x2059;
  18.     printf("%X, %c, %hX\n", a.n, a.ch, a.m);
  19.     a.n = 0x3E25AD54;
  20.     printf("%X, %c, %hX\n", a.n, a.ch, a.m);
  22.     return 0;
  23. }

image.png
小端模式下的存储结构
image.png
大段模式下的存储结构

结构体和共同体的区别

结构体

  • 结构体的各个成员占用不同的内存，成员之间没有相互影响；

  • 结构体占用的内存大于等于所有成员占用的内存的总和（成员之间可能存在内存缝隙）。

    共同体

  • 共同体的所有成员占用同一段内存，修改一个成员会影响其余所有成员；

  • 共同体占用的内存等于最长的成员占用的内存；
  • 共同体使用了内存覆盖技术，同一时刻只能保存一个成员的值，如果对新成员赋值，会把原来成员的值覆盖掉。

    用法示例

    ```c / 设计一个包含共用体的结构体 /

    include

    include

define TOTAL 4

struct memberInfo { char name[20]; int num; char sex; char profession; //作为判断选择union的变量 union S_or_C //共同体保存两个特征——二选一 { float score; char course[20]; } sc; };

int main(void) { struct memberInfo bodys[TOTAL]; //定义一个结构体变量数组，存放多个成员信息 // 输入人员信息 for (int i = 0; i < TOTAL; i++) { printf(“Input data: “); scanf(“%s %d %c %c”, bodys[i].name, &(bodys[i].num), &(bodys[i].sex), &(bodys[i].profession)); if (bodys[i].profession == ‘s’) //判断是否为学生 { scanf(“%f”, &(bodys[i].sc.score)); //输出分数信息 } else { scanf(“%s”, &(bodys[i].sc.course)); //输出课程信息 } fflush(stdin); }

  1. //输出人员信息
  2. printf("\nName\t\tNum\tSex\tProfession\tScore / Course\n");
  3. for (int i = 0; i < TOTAL; i++)
  4. {
  5.     if (bodys[i].profession == 's')
  6.     { //如果是学生
  7.         printf("%s\t%d\t%c\t%c\t\t%f\n", bodys[i].name, bodys[i].num, bodys[i].sex, bodys[i].profession, bodys[i].sc.score);
  8.     }
  9.     else
  10.     { //如果是老师
  11.         printf("%s\t%d\t%c\t%c\t\t%s\n", bodys[i].name, bodys[i].num, bodys[i].sex, bodys[i].profession, bodys[i].sc.course);
  12.     }
  13. }
  14. return 0;

} ```