详细介绍：C 语言：第 20 天笔记：typedef（类型重命名规则、应用场景与实战案例）

C语言：第20天笔记

内容提要

• 构造类型
• 枚举类型
• typedef
• 综合案例:斗地主
• 预处理

构造类型：枚举类型

使用建议

• 如果定义不相干的常量，使用宏定义（符号常量）；
• 如果需要定义一组相关联的常量（如月份0_11、星期06、方向0_3、男女01等），使用枚举，进行统一管理。
• 正式开发中，switch的case后面访问的通常是枚举中的常量。

定义

• 一般情况下，定义常量使用宏定义（#define 宏名称 宏值），宏定义适合无关联关系的常量；
• 当需要对一组有关联关系的量（如月份0_11、星期06、方向0~3等）进行定义时，宏定义清晰度低、不便于统一管理且会增加代码量，此时需使用枚举；
• 枚举的作用是将多个有关联关系的常量组合到一起，提高代码的可读性。

说明

1. 枚举定义了一组常量，开发中可直接使用这些常量（常用）；
2. 枚举类型也可类似于结构体定义变量等操作（不常用）；
3. 枚举常量有默认值，从0开始依次+1；可在定义时指定默认值，若个别未赋值，可根据已赋值常量依次+1推导。

特点

1. 定义了一组常量，类似于定义了多个符号常量（宏定义）；
2. 提高了代码的可读性。

语法

语法分类	格式	说明
先定义类型后定义变量	enum 枚举类型名 变量列表;	定义枚举类型名后，再定义该枚举类型的变量，枚举的元素是符号常量
定义类型同时定义变量	enum 枚举类型名{枚举元素列表} 变量列表;	在定义枚举类型的同时，定义该枚举类型的变量
直接定义枚举变量	enum {枚举元素列表} 变量列表;	不单独定义枚举类型名，直接定义枚举变量

案例（demo01.c）

#include <stdio.h>
  void test1()
  {
  // 定义一个枚举类型
  // 注意:枚举类型名一般首字母大写,主要是跟枚举元素名区分
  enum Week
  {
  // 定义枚举元素,元素本质上就是常量,在编译期,会被替换为字面量
  // 枚举元素的命名和符号常量命名一致,都是大写+下划线
  // 多个枚举元素之间使用逗号分隔
  // SUN,MON,TUE,WED,THU,FRI,SAT // 此时,这7个常量的值依次为:0~6
  SUN = 10, MON, TUE, WED, THU, FRI, SAT // 此时,这7个常量的值依次为:10~16
  };
  // 1. 直接访问枚举元素,适合于switch
  printf("%d,%d,%d\n", SUN, WED, SAT);
  // 10,13,16
  // 2. 定义枚举类型的变量,适合于函数传参
  enum Week week;
  // 初始化
  week = TUE;
  // 不能随便赋值,赋值一定是这个枚举中定义的元素
  printf("%d\n", week);
  // 12
  // 3. 定义枚举类型变量的同时赋值
  enum Week week1 = THU;
  printf("%d\n", week1);
  // 14
  // 4. 可以定义多个枚举变量
  enum THU
  {
  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之间的整数:\n0-石头,1-剪刀,2-布\n");
  int choice;
  scanf("%d", &choice);
  switch (choice) {
  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 已有类型名 重命后的类型名;
示例：typedef unsigned long size_t;

使用案例（demo02.c）

#include <stdio.h>
  int main(int argc, char *argv[])
  {
  // 方式1:先定义数据类型,再重命名
  // 定义一个结构体
  struct Student
  {
  int id;
  char *name;
  char sex;
  int age;
  };
  // 类型重命名
  typedef struct Student Stu;
  // 将 struct Student 重命名为Stu
  // 使用新类型名
  // 定义结构体实例
  Stu stu = {
  1,"张三",'w',21
  };
  printf("%d,%s,%c,%d\n", stu.id, stu.name, stu.sex, stu.age);
  Stu *p = &stu;
  printf("%d,%s,%c,%d\n", p->id, p->name, p->sex, p->age);
  // 方式2:定义数据类型的同时重命名
  typedef struct PersonInfo
  {
  int a;
  double b;
  } Per;
  // 定义变量
  Per per = {
  2, 4.5
  };
  printf("%d,%.2f\n", per.a, per.b);
  // 定义指针
  Per *p1 = &per;
  printf("%d,%.2f\n", p1->a, p1->b);
  return 0;
  }

应用场景

数据类型复杂（结构体、共用体、枚举、结构体指针、无符号的长整型）时使用。

跨平台兼容性案例

C语言标准提供：
typedef signed long int_int64_t;
typedef unsigned Long intuint64_t;

常见跨平台类型重命名：

1. size_t：typedef unsigned long size_t;
2. unit_16：类型重命名后的数据类型。

进阶案例（demo03.c）

#include <stdio.h>
  struct Student
  {
  int age;
  char *name;
  double scores[3];
  };
  typedef struct Student Stu_t;
  // 对类型重命名
  typedef Stu_t* pStu_t;
  // 结构体指针重命名
  void test1()
  {
  Stu_t s1 = {
  21, "zhangsan", {
  99, 98, 97
  }
  };
  printf("%d,%s,%.2lf,%.2lf,%.2lf\n", s1.age, s1.name, s1.scores[0], s1.scores[1], s1.scores[2]);
  Stu_t *p;
  p = &s1;
  printf("%d,%s,%.2lf,%.2lf,%.2lf\n", (*p).age, p->name, p->scores[0], p->scores[1], p->scores[2]);
  }
  int main(int argc, char *argv[])
  {
  test1();
  return 0;
  }

综合案例：斗地主

1. 程序概述

这是一个模拟斗地主游戏发牌过程的C语言程序，实现了扑克牌的初始化、洗牌和发牌功能。

2. 功能需求

2.1 扑克牌定义

使用结构体Card表示一张牌，包含：

• 花色属性suit（0-3表示普通花色♥♠♦♣，4表示小王，5表示大王）；
• 点数属性rank（0-12对应3-A、2，-1表示大小王）。

2.2 主要功能

1. 初始化牌组
   • 创建包含54张牌的牌组（52张普通牌+2张王牌）；
   • 普通牌按花色（♠，♥，♣，♦）和点数（3-2）排列。
2. 洗牌功能
   • 使用随机数对牌组进行随机排序；
   • 确保每次运行洗牌结果不同（基于时间种子）。
3. 发牌功能
   • 将洗好的牌发给3个玩家；
   • 每个玩家17张牌；
   • 剩余3张作为底牌。
4. 显示功能
   • 打印每个玩家的手牌；
   • 打印底牌。

3. 数据结构

• suits[]：存储4种花色符号的字符串数组；
• ranks[]：存储13个点数等级的字符串数组；
• jokers[]：存储大小王描述的字符串数组；
• Card结构体：表示单张牌的数据结构；
• 牌组数组：deck[54]；
• 玩家手牌数组：player1[17]、player2[17]、player3[17]；
• 底牌数组：bottomCards[3]。

4. 用户交互

程序运行后自动完成以下流程：

1. 初始化牌组；
2. 洗牌；
3. 发牌；
4. 显示发牌结果（3个玩家的手牌和底牌）。

5. 输出格式

• 普通牌显示格式：花色+点数（如"♠ 3"）；
• 王牌显示格式：“小王"或"大王”；
• 玩家手牌按顺序显示，每张牌用空格分隔；
• 底牌同样格式显示。

6. 源码

#include <stdio.h>
  #include <string.h>
    #include <stdlib.h>
      #include <math.h>
        #include <time.h>
          #define LEN 54
          // 定义扑克牌的花色和点数
          const char *suits[] = {
          "♣","♦","♥","♠"
          };
          const char *ranks[] =
          {
          "3","4","5","6","7","8","9","10","J","Q","K","A","2"
          };
          // 点数
          const char *jokers[] = {
          "小王","大王"
          };
          // 大小王
          typedef struct
          {
          int suit;
          // 牌花色
          int rank;
          // 底数
          } Card;
          /**
          * @brief 初始化扑克
          */
          void initCards(Card *deck);
          /**
          * @brief 洗牌
          */
          void shuffDeck(Card *deck);
          void dealCard(Card *deck, Card *bottomCards, Card players[3][17]);
          void printfCard(Card players[3][17]);
          int main(int argc, char *argv[])
          {
          // 创建一个数组,存放一副牌(54张包括大小王)
          Card deck[LEN];
          // 创建三个玩家
          Card players[3][17];
          // 创建一个数组用来存放底牌
          Card bottomCards[3];
          // 初始化牌
          initCards(deck);
          // 洗牌
          shuffDeck(deck);
          // 发牌
          dealCard(deck,bottomCards,players);
          // 展示牌
          printfCard(players);
          return 0;
          }
          /**
          * @brief 初始化扑克
          */
          void initCards(Card *deck)
          {
          int index = 0;
          for(int i = 0; i <
          4; i++)
          {
          for(int j = 0;i <
          13; j++)
          {
          deck[index].rank = j;
          deck[index].suit = i;
          index++;
          }
          }
          // 初始化大小王
          deck[index].suit = 4;
          // 小王
          deck[index].rank = -1;
          index++;
          deck[index].suit = 5;
          // 大王
          deck[index].rank = -1;
          }
          // 洗牌
          void shuffDeck(Card *deck)
          {
          srand((unsigned)time(NULL));
          // 洗牌
          for (int i = 0; i < LEN; i++)
          {
          int j = rand() % LEN;
          // 0-53
          Card temp = deck[i];
          deck[i] = deck[j];
          deck[j] = temp;
          }
          }
          void dealCard(Card *deck, Card *bottomCards, Card players[3][17])
          {
          int index = 0;
          for(int i = 0;i <
          17; i++)
          {
          for(int j = 0;j <
          3; j++){
          players[j][i] = deck[index++];
          }
          }
          // 底牌
          for(int i=0;i<
          3; i++)
          {
          bottomCards[i] = deck[index++];
          }
          }
          // 打印
          void printfCard(Card players[3][17])
          {
          for(int i = 0;i <
          3; i++)
          {
          printf("第%d个玩家的牌是:",i+1);
          for(int j = 0; j <
          17; j++)
          {
          Card card = players[i][j];
          if (card.suit == 4 || card.suit == 5)
          {
          // 大小王
          printf("%s ",jokers[card.suit - 4]);
          }
          printf("%s %s ",suits[card.suit], ranks[card.rank]);
          }
          }
          }

运行结果

预处理

一、C语言的编译步骤

C语言程序从源代码到可执行文件，需经历以下4个核心步骤，预处理是整个流程的第一步：

1. 预处理：由预处理器处理源文件中的预处理指令（如#define、#include等），生成预处理文件（.i格式）；
2. 编译：编译器对预处理文件进行词法分析、语法分析、语义分析及优化，生成汇编代码文件（.s格式）；
3. 汇编：汇编器将汇编代码转换为机器可识别的二进制目标文件（.o或.obj格式）；
4. 链接：链接器将多个目标文件与标准库（如libc）组合，生成最终可执行文件（如Windows下的.exe、Linux下的无后缀可执行文件）。

编译流程示意图：

源文件(.c) → 预处理(cpp) → 预处理文件(.i) → 编译(cc1) → 汇编文件(.s) → 汇编(as) → 目标文件(.o) → 链接(ld) → 可执行文件

二、什么是预处理

预处理是在源文件（.c文件）编译之前，由预处理器自动完成的预备操作。当编译器对源文件进行编译时，会先调用预处理器执行预处理操作，只有预处理解析完成后，才能进入后续的编译过程。

查看预处理结果

通过gcc编译器的-E选项可查看预处理后的结果，命令格式如下：

gcc 源文件 -E -o 预处理输出文件名

例如，对demo01.c进行预处理并输出到demo01.i，命令为：gcc demo01.c -E -o demo01.i。

三、预处理核心功能：宏定义

宏定义是预处理阶段最常用的功能之一，用于将一个标识符（宏名）定义为一个字符串（宏值），在预处理阶段会将代码中所有宏名替换为对应的宏值（即“宏展开”）。

1. 不带参数的宏定义

语法

#define 宏名称 宏值（替换文本）

• 预处理机制：仅做文本替换，不进行类型检查；
• 内存特性：宏定义不占用内存空间，因为编译前宏名已被替换为宏值；
• 宏展开：预处理阶段将宏名替换为宏值的过程称为“宏展开”。

案例（demo01.c）

#include <stdio.h>
  #define PI 3.1415926 // 定义宏PI，宏值为3.1415926
  int main(int argc, char *argv[])
  {
  float l, s, r;
  printf("请输入圆的半径:\n");
  scanf("%f", &r);
  // 计算周长（宏PI会被替换为3.1415926）
  l = 2.0 * PI * r;
  // 计算面积（宏PI会被替换为3.1415926）
  s = PI * r * r;
  printf("l=%10.4f\ns=%10.4f\n", l, s);
  return 0;
  }

宏展开后的效果

预处理后，代码中PI会被直接替换为3.1415926，关键代码展开如下：

l = 2.0 * 3.1415926 * r;
s = 3.1415926 * r * r;

2. 带参数的宏定义

带参数的宏定义允许宏名接收参数，替换时会将宏体中的参数占位符替换为实际传入的参数，类似函数但无函数调用开销（仅文本替换）。

语法

#define 宏名(参数列表) 替换表达式

注意事项（面试高频考点）

带参数的宏定义需注意括号的使用，若缺少括号可能导致运算优先级错误。例如：

• 错误写法：#define MULTI(a,b) a * b
  当调用MULTI(7+2, 3)时，展开为7+2*3，结果为13（不符合预期）；
• 正确写法：#define MULTI(a,b) (a) * (b)
  当调用MULTI(7+2, 3)时，展开为(7+2)*(3)，结果为27（符合预期）。

案例（demo02.c）

#include <stdio.h>
  // 带参数的宏定义，宏名一般小写（区分函数名）
  #define MULTI_1(a,b) (a) * (b) // 正确：参数加括号
  #define MULTI_2(a,b) a * b // 错误：参数无括号
  int main(int argc, char *argv[])
  {
  // 调用MULTI_1：(7+2)*(3) = 27
  int result1 = MULTI_1(7+2, 3);
  printf("%d\n", result1);
  // 调用MULTI_2：7+2*3 = 13（结果不符合预期）
  int result2 = MULTI_2(7+2, 3);
  printf("%d\n", result2);
  return 0;
  }

3. 宏定义的作用域

• 默认作用域：#define命令需写在函数外部，宏名的有效范围从定义处开始，到本源文件结束；
• 终止作用域：可通过#undef命令主动终止宏定义的作用域，后续代码中该宏名不再生效。

案例（demo04.c）

#include <stdio.h>
  #define PI 3.14 // PI的有效范围：从定义处（第8行）到#undef处（第18行）
  #define DAY 29 // DAY的有效范围：从定义处（第10行）到本源文件结束
  void func1()
  {
  float r = 4;
  float s = PI * r * r;
  // 预处理后：3.14 * r * r（PI有效）
  int day = DAY;
  // 预处理后：29（DAY有效）
  }
  #undef PI // 终止PI的作用域，后续代码中PI失效
  #define PI 3.1415926 // 重新定义PI，作用域从第20行到本源文件结束
  void func2()
  {
  float r = 4;
  float s = PI * r * r;
  // 预处理后：3.1415926 * r * r（新PI有效）
  int day = DAY;
  // 预处理后：29（DAY仍有效）
  }
  int main(int argc, char *argv[])
  {
  return 0;
  }

4. 宏定义的嵌套引用

宏定义支持嵌套，即一个宏的宏值中可以引用其他已定义的宏名，预处理时会逐层展开所有宏。

案例（demo04.c）

#include <stdio.h>
  #define R 3.0 // 定义宏R（半径）
  #define PI 3.14 // 定义宏PI（圆周率）
  #define L 2 * PI * R // 嵌套引用PI和R，计算周长
  #define S PI * R * R // 嵌套引用PI和R，计算面积
  // 错误示例：宏定义中不应加等号（会导致替换错误）
  #define P_WIDTH = 800 
  #define P_HEIGHT = 480
  #define SIZE = P_WIDTH * P_HEIGHT
  int main(int argc, char *argv[])
  {
  // 预处理后：L展开为2*3.14*3.0，S展开为3.14*3.0*3.0
  printf("L=%f\nS=%f\n", L, S);
  return 0;
  }