15_C语言 -构造类型

构造类型

数据类型

1. 基本类型：
   1. 整型
      1. short / short int（2字节）
      2. 整型（默认） ：int（4字节）
      3. 长整型：long / long int （8字节 （64位系统））
      4. 长长整型：long long / long long int（16字节）
   2. 浮点型
      1. 单精度：float（4字节）
      2. 双精度：double（8字节）
      3. 长双精度：long double（16字节（16位系统））
   3. 字符型：char（1字节）
2. 指针类型
   1. 数据类型*：int*,char*,float*等（8字节）
   2. void*：任意数据类型的指针（万能指针）（8字节）
3. 空类型
   1. void：没有返回值或没有形参（不能定义变量）
4. 自定义类型/构造类型
   1. 结构体类型：struct
   2. 共用体/联合体类型：union
   3. 枚举类型：enum

注意：整型和字符型分有符号signed和无符号unsigned

结构体

结构体的定义

• 定义：自定义数据类型的一种，关键字 struct，结构体类型的变量可以存储多个不同数据类型的数据。

• 定义格式：

  struct 结构体
  {数据类型1 成员名称; // 结构体中的变量叫做成员数据类型2 成员名称;···
  }
  

  注意：结构体中定义的变量，我们称之为成员变量

• 格式说明：

  • 结构体名：合法的标识符，建议单词的首字母大写（所谓的结构体名，就是自定义类型的类型名称）
  • 数据类型n：C语言支撑的所有类型（包括函数，函数在这里用函数指针表示）
  • 成员的名称：合法的标识符，就是变量的命名标准
  • 数据类型n成员名称n：类似于定义变量，定义了结构体中的成员

  标识符：

  说明：变量名、数组名、函数名、常量名、结构体名、共用体、枚举名等都是标识符

  命名规则:

  1. 只能包含字母、数字、下划线
  2. 不能以数字开头

• 注意：

  • 结构体在定义的时候，成员不能赋值

    举例：

    struct Cat
    {int age = 5; // 错误，结构体定义的时候，成员不能赋值double height; // 正确void (*run)(void); // 正确
    }
    

  • 常见的定义格式

    • 方式1：常规定义（命名结构体，只定义类型） --推荐

      struct Studebt
      {int num; // 学号char name[20]; // 姓名char sex; // 姓名int age; // 年龄char address[100]; // 家庭住址void (*info)(void); // 信息输出（函数指针）
      }
      

    • 方式2：定义匿名结构体（常用于作为其他结构体的成员使用）

      struct Dog
      {char *name; // 姓名 int age; // 年龄struct // 结构体{int year;int month;int day;}
      }
      

      注意：定义匿名结构体的同时必须定义结构体变量，否则编译报错，结构体可以作为另一个结构体的成员。

      总结：

      • 结构体可以定义在局部位置，也可以定义在全局位置（用的比较多）。
      • 全局位置的结构体名和局部位置的结构体名可以相同，就近原则（和普通变量的定义同理）

    • 结构体类型的使用：

      利用结构体类型定义变量，定义数组；结构体类型的使用于基本数据类型的使用类似。

结构体变量的定义

• 三种形式定义结构体变量

  结构体变量也称为结构体的实例。

  • 第一种

    ①先定义结构体（自定义数据类型）

    ②然后使用

    struct 结构体名 变量名（实例）；
    

    举例：

    // 先定义结构体（自定义数据类型）
    struct A
    {int a;char b;
    }
    // 后定义结构体变量（使用自定义数据类型）
    struct A x;
    struct A y;
    

  • 第二种

    ①在定义结构体的同时，定义结构体变量

    struct 结构体名
    {数据类型1 数据成员1;···
    }变量列表;
    

    举例：

    struct A
    {int a;int b;
    }x,y;struct A z;
    

    此时定义了一个结构体A，x和y是这个结构体类型的变量。

  • 第三种（不推荐）

    在定义匿名结构体的同时，定义结构体变量

    struct
    {int a;char b;
    }x,y;struct
    {int a;char b;
    } z;
    

    此时定义了一个没有名字的结构体（匿名结构体）；x,y是这个结构体类型的变量。

  • 匿名结构体： -----弊大于利（尽量少用）

    • 优点：少写一个结构体名称
    • 缺点：只能使用一次，定义结构体类型的同时定义变量
    • 作为其他结构体的成员使用。

  • 定义结构体的同时，定义结构体变量初始化

    struct Cat
    {int age;char color[20];
    } cat;
    

  • 结构体成员部分初始化时，大括号{}不能省略

  • 结构体成员，没有默认值，是不确定的数

• 案例：

  /**
  * 结构体变量的定义
  */
  #include <stdio.h>
  // 先定义结构体，再定义结构体变量
  void fun1()
  {// 先定义结构体struct A{int a;char b;};// 再定义结构体变量struct A x;struct A y;
  }
  // 定义结构体的同时定义结构体变量
  void fun2()
  {struct A{int a;char b;} x,y;struct A z;
  }
  // 定义匿名结构体的同时定义结构体变量
  void fun3()
  {struct{int a;// 结构体成员char b;} x,y;// 结构体变量struct{int a;char b;} z;
  }
  int main()
  {fun1();fun2();fun3();return 0;
  }
  

结构体变量的使用

结构体变量访问结构体成员

• 结构体变量访问结构体成员

  • 格式：

    结构体变量名.成员名;
    

    可以通过访问给成员赋值（存数据）

    可以通过访问获取成员的值（取数据）

  • 结构体变量未初始化，结构体的成员值随机（不确定）

• 结构体变量在定义时，可以初始化

  • 建议用大括号表明数据 的范围

  • 结构体成员初始化，可以部分初始化，部分初始化时一定要带

  • 举例：

    #include <stdio.h>
    #include <stdlib.h> //动态内存分配
    #include <string.h> //字符串操作，内存操作
    /*** 结构体变量的使用* */
    // 定义全局的结构体（数据类型）
    struct Dog
    {char* name; //姓名int age; // 年龄char sex; // M：公，W：母void (*eat)(void);
    };void eat()
    {printf("狗狗在吃饭：\n");
    }
    // 先定义在初始化
    void fun1()
    {// 定义结构体变量struct Dog dog;// 给结构体变量赋值，其实就是给其他成员赋值dog.name = "旺财";dog.age = 5;dog.eat = eat;// 访问结构体变量，其实就是访问成员printf("%s,%d,%c\n", dog.name, dog.age, dog.sex);dog.eat();
    }// 定义的同时初始化
    void fun2()
    {// 定义结构体变量并初始化struct Dog dog = {"招财",23,'M'}; // 初始化时，保留大括号// 修改成员的值dog.name = "进宝";// 访问结构体变量，其实就是访问成员printf("%s,%d,%c\n", dog.name, dog.age, dog.sex);
    }
    int main(int argc,char *argv[])
    {fun1();fun2();return 0;
    }

结构体数组的定义

• 什么时候需要结构体数组

  比如：我们需要管理一个学生对象，只需要定义struct Student gaochao;

  假如：我们需要管理多个学生对象，此时就需要一个结构体数组struct Student students[29];

• 三种形式定义结构体数组

  • 第一种：先定义结构体类型，然后定义结构体变量，最后将变量存储到结构体数组

    // 定义一个学生类型的结构体（定义数据类型）
    struct Student
    {char* name;int age;float scores[3];
    }// 定义结构体实例（使用结构体定义变量）
    struct Student zhangsan = {"张三",21,{89,99,78}};
    struct Student lisi = {"李四",22,{56,76,87}};
    // 定义结构体数组
    struct Student stus[3] = {zhangsan,lisi};

  • 第二种：定义结构体类型，，然后定义结构体数组并初始化

    // 定义一个学生类型的结构体
    struct Student
    {int id;char* name;int age;float scores[3];
    }// 定义结构体数组并初始化
    struct Student stus[3] = {{1,"张三",21,{89,99,78}},// 注意：这里赋值的顺序需要跟成员在结构体中的顺序{2,"李四",22,{56,76,87}}
    };
    

  • 第三种：定义结构体类型的同时定义结构体并完成初始化

    // 定义一个学生类型的结构体
    struct Student
    {int id; // 学生编号char* name; // 学生姓名int age; // 学生年龄float scores[3];// 学生三门课成绩
    } stus[3] = {{1,"张三",21,{89,99,78}},// 注意：这里赋值的顺序需要跟成员在结构体中的顺序{2,"李四",22,{56,76,87}}
    

  • 第四种：定义结构体类型的同时定义结构体数组，然后通过索引给结构体成员赋值

    // 定义一个学生类型的结构体
    struct Student
    {int id; // 学生编号char* name; // 学生姓名int age; // 学生年龄float scores[3];// 学生三门课成绩
    } stus[3];
    // 赋值
    stus[0].id = 1;
    stus[0].name = "张三";
    stus[0].age = 21;
    stus[0].scores[0] = 98;
    

小贴士：

结构体数组名访问结构体成员：

格式：结构体数组名 -> 成员名

案例：

#include <stdio.h>
void info(char* str)
{printf("%s\n",str);
}
void fun3()
{// 定义一个学生类型的结构体struct Student{int id;char *name;int age;float scores[3];void (*info)(char*);};// 定义结构体实例并初始化struct Student stu1 = {1,"张三",21,{56,87,99}};struct Student stu2 = {2,"李四",22,{88,66,77}};stu1.info = info;stu2.info = info;// 定义结构体数组并初始化struct Student stus[] = {stu1,stu2};// 遍历结构体数组// 计算数组的大小int len = sizeof(stus) / sizeof(stus[0]);// 遍历for(int i = 0; i < len; i++){printf("%d,%s,%d,%p\n",stus[i].id,stus[i].name,stus[i].age,stus[i].scores);// 其是多个成员都是在访问同一个函数，此时没必要通过下标访问，改变实参就行了stus->info(stus[i].name);}printf("\n");
}
int main(int argc,char *argv[])
{fun3();return 0;
}

优先为指针遍历

#include <stdio.h>
void info(char* str)
{printf("%s\n",str);
}
void fun3()
{// 定义一个学生类型的结构体struct Student{int id;char *name;int age;float scores[3];void (*info)(char*);};// 定义结构体实例并初始化struct Student stu1 = {1,"张三",21,{56,87,99}};struct Student stu2 = {2,"李四",22,{88,66,77}};stu1.info = info;stu2.info = info;// 定义结构体数组并初始化struct Student stus[] = {stu1,stu2};// 遍历结构体数组// 计算数组的大小int len = sizeof(stus) / sizeof(stus[0]);// 遍历struct Student *p = stus;for(; p < stus + len; p++){printf("%d,%s,%d,%p\n",p->id,p->name,p->age,p->scores);// 其是多个成员都是在访问同一个函数，此时没必要通过下标访问，改变实参就行了p->info(p->name);}printf("\n");
}
int main(int argc,char *argv[])
{fun3();return 0;
}   

构造体类型

构造体数组

案例：

需求：对候选人得票的统计程序。设有3个候选人，每次输入一个得票的候选人名字，要求最后输出各人得票的结果。

#include <stdio.h>
#include <string.h>
/**
* 定义一个候选人构造体（对象）
*/
struct Person
{char name[20]; // 候选人名字int count; // 候选人票数
};
/**
* 定义候选人数组，并初始化
*/
struct Person persons[3] = {{"独孤长月",0},{"司空玄烨",0},{"诸葛蛋蛋",0}
};
int main(int argc,char *argv[])
{// 定义循环变量int i,j;// 创建一个char数组，用来存储控制台输入的候选人名字char leader_name[20];// 使用一个循环完成10次投票（模拟投票）for(i = 0; i < 10; i++){printf("请输入您要投票的候选人姓名：\n");scanf("%s",leader_name);// 给被投票的候选人+1票for(j = 0; j < 3; j++){// 判断两个字符串的结果是否相同if(strcmp(leader_name,persons[j].name)==0)persons[j].count++;}}printf("\n投票结果：\n");// 数组法//for(i = 0; i < 3; i++)//{// printf("%s:%d\n",persons[i].name,persons[i].count);//}// 指针法struct Person *p = persons;// p就是构造体指针for(;p < persons + 3;p++)printf("%s:%d\n",p->name,p->count);// 指针法for(i = 0; i < 3; i++){printf("%s:%d\n",(persons+i)->name,(persons+i)->count);}return 0;
}

构造体指针

• 定义：结构体类型的指针变量指向结构体变量或者数组的起始地址。

• 语法：

  struct 结构体名 *指针变量列表;
  

• 举例：

  struct Dog
  {char name[20];int age;
  };
  struct Dog dog = {"富贵",5};
  struct Dog *p = &dog;
  

构造体成员访问

• 结构体数组名访问结构体成员

  • 格式：结构体数组名 -> 成员名;

  • 举例：

    printf("%s:%d\n",persons->name,persons->count);
    

• 结构体成员访问符

  • . ：左侧是结构体变量（结构体对象/结构体实例），也可以叫做结构体对象访问成员符，右侧是结构体成员

  • -> ：左侧是一个指针，也可以叫做结构体指针访问成员符，右侧是结构体成员

  • 举例：

    // 指针法
    struct Person *p = persons;// p就是构造体指针
    for(;p < persons + 3;p++)printf("%s:%d\n",p->name,p->count);
    

• 访问结构体成员有两种类型，三种方式：

  1. 类型1：通过结构体对象访问成员

     struct Stu
     {int id;// 结构体成员char name[20];
     } stu;// 结构体变量
     // 访问成员
     stu.name;
     

  2. 类型2：通过结构体指针访问成员

     • 第1种：指针引用访问成员

       struct Stu
       {int id;// 结构体成员char name[20];
       } stu;// 结构体变量
       struct Stu *p = &stu;
       // 指针引用访问成员
       p -> name;
       

     • 第2种：指针解引用间接访问成员

       struct Stu
       {int id;// 结构体成员char name[20];
       } stu;// 结构体变量
       struct Stu *p = &stu;
       // 指针解引用访问成员
       (*p).name;
       

• 结构体数组中元素的访问

  struct Stu
  {int id;char name[20];float scores[3];
  } stus[3] = {{1,"张三",{67,77,88}},// (stus+1){2,"李四",{90,99,98}},{3,"王五",{88,97,77}}
  };
  // 取数据 -- 下标法
  printf("%s,%.2f\n",stus[1].name,stus[1].scores[1]);// 李四，99
  // 取数据 -- 指针法（->）
  printf("%s,%.2f\n",stus -> name,stus -> scores[2]);// 张三，88
  printf("%s,%.2f\n",(stus+1) -> name,(stus+1) -> scores[2]);// 李四，98
  printf("%s,%.2f\n",(*(stus+1)).name,(*(stus+1)).scores[2]);// 李四，98
  

小贴士：

结构体是自定义数据类型，它是数据类型，用法类似于基本类型的int；

结构体数组它是存放结构体对象的数组，类似于int数组存放int数据；

基本类型数组怎么用，结构体数组就怎么用—>可以遍历，可以作为形式参数，也可以做指针等；

• 结构体类型的使用案例

  结构体可以作为函数的返回类型、形式参数。

  代码：

  #include <stdio.h>
  // 定义结构体
  struct Cat
  {char *name;// 姓名int age;// 年龄char color[20];// 颜色
  }
  // 1.结构体类型作为形式参数
  void test1(struct Cat c);
  // 2.结构体类型作为形式参数，结构体类型作为返回值类型
  struct Cat test2(struct Cat c);
  // 3.结构体数组作为形式参数
  void test3(struct Cat cats[],int len);
  // 4.结构体数组作为形式参数，结构体指针作为返回值数据类型
  struct Cat *test4(struct Cat cats[],int len);
  

  测试：

  int main()
  {// 定义结构体对象struct Cat cat = {"小黑",8,"baise"};// 结构体对象作为实际参数test1(cat);// 定义结构体类型对象struct Cat cat1 = {"小白",8,"heise"};// 调用函数并接收返回值struct Cat c1 = test2(cat1);// 通过返回值访问结构体对象的成员printf("%s==%d==%s\n",c1.name,c1.age,c1.color);// 定义结构体数组struct Cat cats[3] = {{"汤姆",16,"蓝色"},{"杰瑞",18,"褐色"},{"唐老鸭",19,"白色"}};// 结构体数组名作为实际参数test3(cats,3);// 定义结构体数组并初始化struct Cat cats1[3] = {{"汤姆",16,"蓝色"},{"杰瑞",18,"褐色"},{"唐老鸭",19,"白色"}};// 调用函数struct Cat *p = test4(cats1,3);struct Cat *w;// 通过指针运算遍历数组for(w = p; w < p + 3; w ++){// p[i][j] = *(p[i]+j) = *(*(p+i)+j) 三者等价// 通过结构体指针访问符访问结构体的成员printf("%s----%d----%s\n",w -> name,w -> age,w -> color);}
  }
  

构造体类型求大小

• 规则：字节对齐（默认，数据在内存中存储在其类型大小的整数倍上）

  • 首先保证结构体中的成员存储在自身的对齐边界（类型大小的整数倍）

  • 在满足1的条件下，最终大小要满足最大成员所占存储单元的整数倍。

• 为什么要使用字节对齐

  节省内存，提高访问效率

• 在GNU标准中，可以在定义结构体时，指定对齐规则：

  __attribute__((packed)); -- 结构体所占内存大小是所有成员所占内存大小之和
  __attribute__((aligned(n))); -- 设置结构体占n个字节，如果n比默认值小，n不起作用；n必须是2的次方
  

• 案例：

  #include <stdio.h>
  int main(int argc,char *argv[])
  {struct Cat{char sex __attribute((aligned(2)));// 1 -- 2int id;// 4char name[20];// 20} __attribute__((packed)); // 结构体所占内存大小是所有成员所占内存大小之和printf("%ld\n",sizeof(struct Cat));// 默认字节对齐（28）/ 使用packed后（25）return 0;
  }
  

• 柔性数组

  struct St
  {...char arr[0];
  }
  

  柔性数组不占有结构体的大小。

  案例：

  #include <stdio.h>
  int main(int argc,char *argv[])
  {struct Cat{char sex __attribute((aligned(2)));// 1 -- 2int id; // 4char arr[0]; // 0 柔性数组不占用结构体的大小char name[20]; // 20} __attribute__((packed)); // 结构体所占内存大小是所有成员所占内存大小之和printf("%ld\n",sizeof(struct Cat));// 默认字节对齐（28）/ 使用packed后（25）/ 使用aligned之后（26）return 0;
  }
  

课堂练习

计算以下结构体的大小

#include <stdio.h>
// 定义测试结构体
struct TEST1
{char a;// 1 + 3int b; // 4
};
struct TEST1_1
{char a;// 1int b;// 4
}__attribute__((packed));// 取消字节对齐，取消之后，结构体数据类型大小就等于其所有成员的数据类型
之和struct TEST1_2{char a __attribute__((aligned(2)));// 2 + 2int b;// 4};
struct TEST2
{char a;// 1+1short c; // 2int b; // 4
};
struct TEST3
{int num;// 4char name[10];// 10char sex;// 1+1int age;// 4 + 4double score;// 8
};
struct TEST3_1
{int num;// 4char name[10];// 10char sex;// 1+1double score;// 8int age;// 4+4
};
struct TEST4
{int num;// 4short name[5];// 10char sex;// 1+1int age;// 4int scores[2];// 8
};
int main(int argc,char *argv[])
{// 创建结构体变量struct TEST1 test1;struct TEST2 test2;struct TEST3 test3;struct TEST3_1 test3_1;struct TEST4 test4;struct TEST1_1 test1_1;struct TEST1_2 test1_2;// 计算大小printf("%lu\n",sizeof(test1));// 8printf("%lu\n",sizeof(test2));// 8printf("%lu\n",sizeof(test3));// 32printf("%lu\n",sizeof(test3_1));// 28printf("%lu\n",sizeof(test4));// 28printf("%lu\n",sizeof(test1_1));// 5printf("%lu\n",sizeof(test1_2));// 8return 0;
}

快速计算结构体大小：

https://blog.csdn.net/weixin_72357342/article/details/131135555 https://blog.csdn.net/x2528238270/article/details/120798606

共用体**/**联合体类型

• 定义：使几个不同的变量占用同一段内存的结构。共用体按定义中需要存储空间最大的成员来分配存储单元，其他成员也是用该空间，他们的首地址是相同。

• 定义格式：

  union 共用体名称
  {数据类型 变量名; -- 共用体成员数据类型 变量名;...
  };
  

• 公用体的定义和结构体类似：

  • 可以有名字，也可以匿名
  • 共用体在定义时也可以定义公用体变量
  • 共用体在定义时也可以初始化成员
  • 共用体也可以作为形参和返回值类型使用
  • 共用体也可以定义共用体变量

  也就是说，结构体的语法，共用体都支持

• 注意：

  • 共用体弊大于利，尽量少用，一般很少用；

  • 共用体变量在某一时刻只能存一个数据，并且也只能取出一个数

  • 共用体和结构体都是自定义数据类型，用法类似于基本数据类型

    • 共用体可以是共用体的成员，也可以是结构体的成员
    • 结构体可以是结构体的成员，也可以是共用体的成员

  • 案例：

    /**
    * 共用体
    */
    #include <stdio.h>
    // 定义共用体
    union S
    {char a;float b;int c;
    };// 大小是4字节
    // 共用体作为共用体的成员
    union F
    {char a;union S s; // 4字节
    };// 大小是4字节
    // 共用体作为结构体的成员
    struct G
    {int a;union S s;
    };// 大小是8字节
    // 定义一个结构体
    struct H
    {int a;char b;
    };// 大小是8字节
    // 结构体作为结构体成员
    struct I
    {int a; // 4int b; // 4struct H h; // 8
    };// 大小是16字节
    // 共用体作为结构体成员
    struct J
    {int a;// 4char b;// 1 + 3union S s;// 4
    };// 大小是12字节
    void test1()
    {// 定义共用体类型union Stu{int num;char sex;double score;};// 定义匿名共用体：匿名共用体一般作为结构体成员或者其他共用体成员union{int a;char c;} c;printf("%lu,%lu\n",sizeof(union Stu),sizeof(c));
    }
    void test2()
    {union C{int a;char b;};// 定义变量union C c;// 存数据c.a = 10;c.b = 'A';printf("%d---%d\n",c.a,c.b);// 取数据c.a += 5;printf("%d---%d\n",c.a,c.b);// 取数据union E{char *f;long a;int b;} e = {"hello world!"};printf("%s,%p---%ld,%p---%d\n",e.f,&(e.f),e.a,&(e.a),e.b);
    }
    int main()
    {test1();test2();
    }
    

枚举类型

枚举类型

建议，如果定义不相干的常量，使用宏定义；如果需要定义一组相关的常量，使用枚举。以后正式开发，switch的case后访问的就是枚举。

• 定义 ：

  我们一般情况下，定义常量使用宏定义（#defne宏名称值），宏定义非常适合没有关联关系的常量；但是有时候我们可能需要对一组有关联关系的量进行定义，比如==周一~周日、1月~12月、方向（上下左右中）等，那么使用宏定义，就不是很清晰，这个时候就需要使用到枚举。

  枚举的存在就是多个将拥有多个关系的常量组合到一起，提高代码的可读性。

• 枚举类型 定义了一组常量，我们在开发中直接使用这些常量。（常用）

• 当然枚举类型也可以类似于结构体一样定义变量等操作。（不常用）

• 枚举常量有默认值，从0开始依次+1；我们可以在定义 时指定它的默认值，如果个别没有赋值，可以根据赋值依次+1推导。

• 特点：

  定义了一组常量，类似于定义了多个自定义常量（宏定义）

  提高了代码的可读性。

• 定义语法：

  枚举类型名以后就可以定义该枚举类型的变量。

  enum 枚举类型名 变量列表；
  

  在定义枚举类型的同时定义该枚举类型的变量。

  enum 枚举类型名{枚举元素列表} 变量列表；
  

  直接定义枚举变量

  enum {枚举元素列表} 变量列表;
  

案例：

#include <stdio.h>
void test1()
{// 定义一个枚举类型// 枚举类型名一般首字母大写，主要是根枚举变量区分enum Week{// 定义枚举元素，元素命名要符合标识符命名规则，同时采用大写字母+下划线方式命名SUN=10,MON,TUE,WED,THU,FRI,SAT};// 1.直接访问枚举元素printf("%d,%d,%d\n",SUN,WED,SAT);// 2.定义枚举类型的变量（先定义变量，后赋值）enum Week week;// 初始化week = TUE;// 一定是这个枚举类型中定义的元素printf("%d\n",week);// 3.定义枚举类型变量的同时赋值（定义变量和赋值同时进行）enum Week week1 = THU;printf("%d\n",week1);enum H{A,B,C // 多个元素使用逗号分隔} x,y;x = B;y = C;printf("x=%d,y=%d\n",x,y);// 1,2
}
void test2()
{// 定义枚举enum CaiQuan{SHI_TOU,JIAN_DAO,BU};printf("请输入0~2之间的整数：\n[0-石头，1-剪刀，2-布]\n");int number;scanf("%d",&number);switch(number){case SHI_TOU:printf("石头\n");break;case JIAN_DAO:printf("剪刀\n");break;case BU:printf("布\n");break;}
}
int main(int argc,char *argv[])
{test1();test2();return 0;
}

typedef

• 说明：给类型重命名，不会影响到类型本身

• 作用：给已有的类型起别名

• 格式：

  typedef 已有类型名 新别名;
  

• 使用：

  // 方式1：先定义结构体类型，在重命名
  // 定义一个结构体
  struct Student{int id;char *name;char sex;int age;
  };// 类型重命名
  typedef struct Student Stu;// 定义结构体变量
  struct Stu stu = {1,"张三",'w',21};// 方式2：定义结构体的同时重命名
  typedef struct PersonInfo{int a;double b;
  }Per; // 结构体类型的别名，本质上还是数据类型// 定义变量
  struct Per per = {2,5};
  

• 应用场景 ：

  • 数据类型复杂（结构体、共用体、枚举、结构体指针、无符号的长整型）时使用
  • 为了跨平台兼容性，例如：
    1. size_t：类型重命名后的数据类型：typedef unsigned long size_t;
    2. unit_16：类型重命名后的数据类型

• 案例：

//类型重命名
#include <stdio.h>
struct Student
{int age;char* name;double score;int arr[3];
};
typedef struct Student Stu_t;// 数据类型重命名
typedef Stu_t* pStu_t;// 结构体指针重命名
void test1()
{Stu_t s1 = {23, "zhangsan", 23.33, {11, 22, 33}};printf("%d, %s, %f, %d\n", s1.age, s1.name, s1.score, s1.arr[0]);//Stu_t *p = &s1;Stu_t* p;p = &s1;pStu_t p2;p2 = p;printf("%d, %s, %f, %d\n", p2->age, p2->name, p2->score, p2->arr[0]);
}
int main()
{test1();return 0;
}