程序结构

• 结构

局部变量：用简单的描述一下作用域和生存期：

作用域：限定某个名字的可用性的代码范围就是该名字的作用域

生存期：变量值存在的时间

块：一个花括号{}就是一个块。

通常来说，变量的作用域和生存期都是在一个块内。

1. 静态局部变量

在局部变量中放置单词 static 可以使变量具有静态存储期限而不再是自动存储期限。

因为具有静态存储期限的变量拥有永久的存储单元，所以在整个程序的执行期间都会保留变量的值。比如：

void func(){
int static n; // static locol variable
}
在函数 func 返回时，变量 n 的值不会丢失。

静态局部变量虽然生存期是整个程序，但是作用域尽在其所定义的块内。也就是说，上例中函数 func 返回后，func 内的 n 就不再可用。

2.全局变量

文件作用域。全局变量的作用域：从变量被声明的点开始一直到所在文件的末尾。外部变量声明之后的函数都可以访问（并修改）它
在大多数情况下，对于函数而言，传参比共享变量更好

不建议使用全局变量。

从头到尾去写一个 c 程序。我们这里给出比较好的编排顺序：

1. include指令

2. define指令

3. 类型定义

4. 全局变量声明

5. 函数原型

6. main 函数定义

7. 其他函数定义

   /*
   * 程序难点思路：
   * 1）为了判定手中的牌是否重复，我们需要一个布尔类型数组存储整副牌，初始化整个数组为 false。如果一张牌已经在我们手上，那么我们将数组对应的元素置为 true
   * 2）用两个分别数组来存储每个点数和花色的个数，这样方便我们后面判断牌的类型
   * 3）8 种牌的类型，我们可拆成 同花，顺子，4张，3张，对子（值为 0，1，2）这五种基础类型的组合。
   *
   * 程序结构：
   * 通过上面的分析，我们发现：这个程序需要 3 个数组和 5 个变量，如果都作为函数参数传参，显得有些笨。
   * 而且，前面我们说过，函数只能返回一个值，那如果要将函数分离， 5 种基础类型就得放进数组；或者使用指针，而指针我们没有学习，而且指针还是逃不开传参
   * 这样一分析，貌似使用全局变量是最好的做法了。对于初学者来说，这样可能确实是最好的。
   * 但是，使用大量的全局变量是很不好的习惯，我不能让自己去写这样的代码。我认为：宁可这道题不做，也不能有坏的代码风格去写！
   * 后面我们会学习自定义类型：结构体，它可能是这种问题最好的解决方法。
   *
   * 下面是这个问题的 4 种解决方法：
   * 1)应用全局变量
   * 2）应用指针作为函数参数
   * 3）将判断卡牌类型的函数与打印函数合并
   * 4）使用结构体
   *
   * 在这里，我坚持使用结构体来解决这类问题。全局变量大家只要知道概念即可，对于这道题来说，比起方法，可能设计程序的模块化思路更值得学习。
   * 即使使用结构体，程序的主要逻辑也不会变。如果你非要用全局变量写，那你可以改写一下。
   */

   `#include<stdio.h>

   include<stdbool.h>

   define RANK 13

   define SUIT 4

   define CARD 5

   typedef struct CardType {
   bool flush; //同花
   bool straight; //顺子
   bool four; //四张
   bool three; //三张
   int pair; // 对子
   // 0 表示不是 1 表示 1个对子 2 表示两个对子
   bool cardInHand[SUIT][RANK]; // 判断此牌是否已在手中
   int numRank[RANK]; // 每个点数的个数
   int numSuit[SUIT]; // 每个花色的个数
   }CardType;

   void initCardType(CardType* card); // 初始化
   void readCard(CardType* card); // 读取输入
   void analyseCard(CardType* card); // 分析手牌
   void printResult(CardType* card); //打印结果

   int main(void) {

   CardType card;

   for (; 😉 {
   initCardType(&card);
   readCard(&card);
   analyseCard(&card);
   printResult(&card);
   }

   return 0;
   }

   void initCardType(CardType* card) {

   card->flush = false;
   card->straight = false;
   card->four = false;
   card->three = false;
   card->pair = 0;

   int i, j;

   for (i = 0; i < SUIT; i++) {
   card->numSuit[i] = 0;
   for (j = 0; j < RANK; j++) {
   card->cardInHand[i][j] = false;
   }
   }

   for (i = 0; i < RANK; i++) {
   card->numRank[i] = 0;
   }

   }

   void readCard(CardType* card) {

   int card_read = CARD, rank, suit;
   bool bad_card;
   char ch;

   while (card_read) {

   bad_card = false; // 不要忘记重置坏牌的标记

   printf("Enter a card : ");

   // 判断点数
   ch = getchar();
   switch (ch) {
   case '0': exit(0); break;
   case '2': rank = 0; break;
   case '3': rank = 1; break;
   case '4': rank = 2; break;
   case '5': rank = 3; break;
   case '6': rank = 4; break;
   case '7': rank = 5; break;
   case '8': rank = 6; break;
   case '9': rank = 7; break;
   case 't':case 'T': rank = 8; break;
   case 'j':case 'J': rank = 9; break;
   case 'q':case 'Q': rank = 10; break;
   case 'k':case 'K': rank = 11; break;
   case 'a':case 'A': rank = 12; break;
   default:bad_card = true; break;
   }

   ch = getchar();
   switch (ch) {
   case 'c': case 'C': suit = 0; break;
   case 'd': case 'D': suit = 1; break;
   case 'h': case 'H': suit = 2; break;
   case 's': case 'S': suit = 3; break;
   default: bad_card = true; break;
   }

   // 检测输入是否多于两个字符
   while ((ch = getchar()) != '\n') {
   if (ch != ' ')
   bad_card = true;
   }

   if (bad_card)
   printf("Bad card; ignored.\n");
   else if (card->cardInHand[suit][rank])
   printf("Duplicated card; ignored.\n");
   else {
   ++card->numRank[rank];
   ++card->numSuit[suit];
   card->cardInHand[suit][rank] = true;
   card_read--;
   }
   }
   }

   void analyseCard(CardType* card) {

   int i, count;

   // 同花是五张牌相同花色
   for (i = 0; i < SUIT; i++) {
   if (card->numSuit[i] == 5)
   card->flush = true;
   }

   // 顺子是五张连续的牌，中间不能隔断

   i = 0;
   // 找到数组种第一张存在的牌
   while (card->numRank[i] == 0)
   i++;
   count = 0;
   for (; i < RANK && card->numRank[i] != 0; i++) {
   count++;
   }
   // 顺子必须是五张
   if (count == CARD) {
   card->straight = true;
   return; // 顺子肯定不是对子
   }

   for (i = 0; i < RANK; i++) {
   if (card->numRank[i] == 4)
   card->four = true;
   if (card->numRank[i] == 3)
   card->three = true;
   if (card->numRank[i] == 2)
   ++card->pair;
   }

   }

   void printResult(CardType* card) {

   if (card->flush && card->straight)
   printf("Stright flush\n");
   else if (card->four)
   printf("Four of a kind\n");
   else if (card->three && card->pair == 1)
   printf("Full house\n");
   else if (card->flush)
   printf("flush\n");
   else if (card->straight)
   printf("straight\n");
   else if (card->three)
   printf("Three of a kind\n");
   else if (card->pair == 2)
   printf("Two pairs\n");
   else if (card->pair == 1)
   printf("pair\n");
   else
   printf("High card\n");

   printf("\n\n");
   }`