C语言之三字棋的简单实现及扩展

在我们学习完数组之后，我们完全可以利用数组相关知识来写一个微小型的游戏，比如说今天所说的——三子棋。

大纲：

　　 文件组成

　　 实现

 　　完整代码展示

 　　扩展

即：

一.文件组成：

在我们学习的过程中，我们要逐渐习惯多文件的书写方式，也就是模块化书写。

在本文中，笔者分为了三个文件来写，分别是：

　　1.game.h——实现游戏函数的声明

　　2.game.c——游戏函数的实现

　　3.test.c —— 测试及游戏函数的调用

二.实现

0.文件的初始化

在这里我们分别在我们所创建的 test.c 和 game.c 包含我们的头文件——game.h

1.菜单的实现

在菜单中，我们设置玩家可以选择的模式，play and quit

以及，菜单怎么样多次循环选择，菜单的容错处理。这里，我们利用 do-while 来实现。

  1. #define _CRT_SECURE_NO_WARNINGS 1//加这一句话是因为笔者采用的是 VS 编译器，为了防止一些不必要的错误出现
  2.  
  3. #include "game.h"
  4.  
  5. void menu()//列出可供玩家选择的模式
  6. {
  7.     printf("**************************************************************\n");
  8.     printf("*****************         1.play              ****************\n");
  9.     printf("*****************         0.exit              ****************\n");
  10.     printf("**************************************************************\n");
  11. }
  12.  
  13. void play()
  14. {
  15.  
  16. }
  17.  
  18. int main()
  19. {
  20.     int input;//在这里，我们利用玩家选择的模式来控制循环的终止
  21.     do
  22.     {
  23.         menu();
  24.         printf("请输入你的选择：");
  25.         scanf("%d", &input);
  26.         switch (input)
  27.         {
  28.         case 1://play
  29.             play();
  30.             break;
  31.         case 0://退出
  32.             printf("欢迎下次再来！\n");
  33.             break;
  34.         default://当玩家输入了非法字符，让其重新选择
  35.             printf("输入错误，请重新输入！\n");
  36.         }
  37.     } while (input);//当input为0时，停止循环
  38.  
  39.     return 0;
  40. }

运行效果：

现在，我们的菜单已经做好了，接下来要做的就是来打印我们的棋盘。

2.棋盘的打印

这里我们把打印函数的声明放在 game.h 文件里，把实现放在game.c 文件中。

在写代码之前，我们先来想一想在棋盘打印中，我们能不能直接打印空格——这肯定是不能的，因为这样，我们在屏幕上什么都看不见 (≧∇≦)ﾉ

game.c:

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include"game.h"
  4.  
  5. void InitBoard(char board[3][3], int row, int col)//棋盘初始化
  6. {
  7.     int i = 0, j = 0;
  8.     for (i = 0; i < row; i++)
  9.     {
  10.         for (j = 0; j < col; j++)
  11.         {
  12.             board[i][j] = ' ';
  13.         }
  14.     }
  15. }
  16.  
  17. void DisplayBoard(char board[3][3], int row, int col)//棋盘打印函数
  18. {
  19.     int i = 0, j = 0;
  20.     for (i = 0; i < row; i++)
  21.     {
  22.         for (j = 0; j < col; j++)
  23.         {
  24.             printf(" %c ", board[i][j]);
  25.             if (j < col - 1)
  26.             {
  27.                 printf("|");//分割列
  28.             }
  29.         }
  30.         printf("\n");
  31.  
  32.         if (i < row - 1)
  33.         {
  34.             for (j = 0; j < 3; j++)
  35.             {
  36.                 printf("---");//分割行
  37.                 if (j < col - 1)
  38.                 {
  39.                     printf("|");
  40.                 }
  41.             }
  42.         }
  43.         printf("\n");
  44.     }
  45. }

注：

　　为了避免文章赘余，test.c 以及 game.h不再表示

运行结果：

但是，我们这么写，会不会有问题？

值得注意的是，在这有人会把棋盘打印写成这个样子

  1. void DisplayBoard(char board[3][3], int row, int col)//棋盘打印函数
  2. {
  3.     for (int i = 0; i < 3; i++)
  4.     {
  5.         printf(" %c | %c | %c \n", board[i][0], board[i][1], board[i][2]);
  6.         if (i < 2)
  7.         {
  8.             printf("---|---|---\n");//分割行
  9.         }
  10.     }
  11. }

这样，无非还是上面那个问题，代码写死，无法扩展

所以，我们在这利用宏来实现，棋盘的大小随我们的宏来改变

因此在这我们给出头文件的部分

  1. #pragma once
  2.  
  3. #include<stdio.h>
  4.  
  5. #define ROW 3//利用宏来实现棋盘的大小
  6. #define COL 3
  7.  
  8. void InitBoard(char board[ROW][COL], int row, int col);//棋盘初始化
  9.  
  10. void DisplayBoard(char board[ROW][COL],int row, int col);//棋盘打印函数

3.棋盘下子

1.玩家下子

在这里我们一共要注意几点：

　　1.在下子之前，我们要判断玩家所要下的位置是否在棋盘内

　　2.检测玩家要下的位置是否已有了棋子

　　3.下子之后，检查棋盘的输赢状况 (这个我们后面再说)

  1. void PlayerMove(char board[ROW][COL], int row, int col)//玩家下棋
  2. {
  3.     int x, y;
  4.     printf("玩家走：\n");
  5.     printf("请输入你所要落子的坐标：");
  6.     scanf("%d%d", &x, &y);
  7.     if (board[x - 1][y - 1]!=' ')//坐标被占用
  8.     {
  9.         printf("该坐标已被占用，请重新下子！\n");
  10.     }
  11.     else if (!((x > 0 && x <= row) && (y > 0 && y <= col)))
  12.     {
  13.         printf("该坐标为非法坐标，请重新输入！\n");//坐标非法
  14.     }
  15.     else
  16.     {
  17.         board[x - 1][y - 1] = '*';//玩家落子，暂时用 * 来表示
  18.     }
  19. }

2.电脑下子

再这里我们暂不深究，使用随机函数来生成一个坐标来下子

  1. void ComputerMove(char board[ROW][COL], int row, int col)//电脑下棋
  2. {
  3.     int x, y;
  4.     printf("电脑走：");
  5.     while (1)
  6.     {
  7.          x = rand() % row;
  8.          y = rand() % col;
  9.          if (board[x][y] == ' ')
  10.          {
  11.              board[x][y] = '#';//这里我们用 # 来表示电脑下棋
  12.              break;
  13.          }
  14.     }
  15. }

4.胜负的判定

在这里，我们用一个函数的返回值来表示输赢的各个情况。

#-----电脑赢

*-----玩家赢

C-----继续下子

F-----和局

  1. int ISFULL(char board[ROW][COL], int row, int col)
  2. {
  3.     int i = 0, j = 0;
  4.     for (i = 0; i < row; i++)
  5.     {
  6.         for (j = 0; j < col; j++)
  7.         {
  8.             if (board[i][j] == ' ')
  9.                 return 0;
  10.         }
  11.     }
  12.     return 1;
  13. }
  14.  
  15. char ISWIN(char board[ROW][COL], int row, int col)
  16. {
  17.     int i = 0, j = 0;
  18. for (i = 0; i < row; i++)
  19.     {
  20.         for (j = 0; j < col - 2; j++)
  21.         {
  22.             //判断横行
  23.             if (board[i][j] == board[i][j + 1] && board[i][j] == board[i][j + 2] && board[i][j] != ' ')
  24.                 return board[i][j];
  25.             //判断主对角线
  26.             else if (board[i][j] == board[i + 1][j + 1] && board[i + 2][j + 2] == board[i][j] && board[i][j] != ' ')
  27.                 return board[i][j];
  28.             //判断副对角线
  29.             else if (board[col - 1 - i][j] == board[col - 2 - i][j + 1] && board[col - 3 - i][j + 2] == board[col - 1 - i][j] && board[col - 1 - i][j] != ' ')
  30.                 return board[col - 1 - i][j];
  31.         }
  32.     }
  33.     for (i = 0; i < row - 2; i++)
  34.     {
  35.         for (j = 0; j < col; j++)
  36.         {
  37.             //判断竖行
  38.             if (board[i][j] == board[i + 1][j] && board[i][j] == board[i + 2][j] && board[i][j] != ' ')
  39.                 return board[i][j];
  40.         }
  41.     }

　　　　//判断是否满盘---放在最后是因为最后一步的判断
　　　　if (1 == ISFULL(board, row, col))
　　　　{
　　　　　　return 'F';
　　　　}

  1. return 'C';
  2. }

到这，我们的三子棋似乎已经编完了，先看一下运行结果：

    

在这个过程中，我们会发现电脑下的特别快（当然，这跟我们的懒惰有关……）所以我们在电脑下的步骤中加一个Sleep（）函数来延长电脑所用时间

已即，我们可以下一次子就清一下屏，这样看起来比较舒服

所以

最后的代码部分：

  1. #pragma once
  2.  
  3. #include<stdio.h>
  4. #include<stdlib.h>
  5. #include<time.h>
  6. #include<Windows.h>
  7.  
  8. #define ROW 3//利用宏来实现棋盘的大小
  9. #define COL 3
  10.  
  11. void InitBoard(char board[ROW][COL], int row, int col);//棋盘初始化
  12.  
  13. void DisplayBoard(char board[ROW][COL], int row, int col);//棋盘打印函数
  14.  
  15. void PlayerMove(char board[ROW][COL], int row, int col);//玩家下棋
  16.  
  17. void ComputerMove(char board[ROW][COL], int row, int col);//电脑下棋
  18.  
  19. char ISWIN(char board[ROW][COL], int row, int col);//判断输赢
  20.  
  21. int ISFULL(char board[ROW][COL], int row, int col);//判断棋盘是否已满

game.h

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include"game.h"
  4.  
  5. void InitBoard(char board[ROW][COL], int row, int col)//棋盘初始化
  6. {
  7.     int i = 0, j = 0;
  8.     for (i = 0; i < row; i++)
  9.     {
  10.         for (j = 0; j < col; j++)
  11.         {
  12.             board[i][j] = ' ';
  13.         }
  14.     }
  15. }
  16.  
  17. //void DisplayBoard(char board[3][3], int row, int col)//棋盘打印函数
  18. //{
  19. //    for (int i = 0; i < 3; i++)
  20. //    {
  21. //        printf(" %c | %c | %c \n", board[i][0], board[i][1], board[i][2]);
  22. //        if (i < 2)
  23. //        {
  24. //            printf("---|---|---\n");
  25. //        }
  26. //    }
  27. //}
  28.  
  29. void DisplayBoard(char board[ROW][COL], int row, int col)//棋盘打印函数
  30. {
  31.     int i = 0, j = 0;
  32.     for (i = 0; i < row; i++)
  33.     {
  34.         for (j = 0; j < col; j++)
  35.         {
  36.             printf(" %c ", board[i][j]);
  37.             if (j < col - 1)
  38.             {
  39.                 printf("|");//分割列
  40.             }
  41.         }
  42.         printf("\n");
  43.  
  44.         if (i < row - 1)
  45.         {
  46.             for (j = 0; j < 3; j++)
  47.             {
  48.                 printf("---");//分割行
  49.                 if (j < col - 1)
  50.                 {
  51.                     printf("|");
  52.                 }
  53.             }
  54.         }
  55.         printf("\n");
  56.     }
  57. }
  58.  
  59. void PlayerMove(char board[ROW][COL], int row, int col)//玩家下棋
  60. {
  61.     int x, y;
  62.     printf("玩家走：\n");
  63.     while (1)
  64.     {
  65.         printf("请输入你所要落子的坐标：");
  66.         scanf("%d%d", &x, &y);
  67.         if (!((x > 0 && x <= row) && (y > 0 && y <= col)))
  68.         {
  69.             printf("该坐标为非法坐标，请重新输入！\n");//坐标非法
  70.         }
  71.         else if (board[x - 1][y - 1] != ' ')//坐标被占用
  72.         {
  73.             printf("该坐标已被占用，请重新下子！\n");
  74.         }
  75.         else
  76.         {
  77.             board[x - 1][y - 1] = '*';//玩家落子，暂时用 * 来表示
  78.             break;
  79.         }
  80.     }
  81.     system("cls");
  82. }
  83.  
  84. void ComputerMove(char board[ROW][COL], int row, int col)//电脑下棋
  85. {
  86.     int x, y;
  87.     printf("电脑走：\n");
  88.     Sleep(1000);
  89.     while (1)
  90.     {
  91.          x = rand() % row;
  92.          y = rand() % col;
  93.          if (board[x][y] == ' ')
  94.          {
  95.              board[x][y] = '#';//这里我们用 # 来表示电脑下棋
  96.              break;
  97.          }
  98.     }
  99.     system("cls");
  100. }
  101.  
  102. int ISFULL(char board[ROW][COL], int row, int col)
  103. {
  104.     int i = 0, j = 0;
  105.     for (i = 0; i < row; i++)
  106.     {
  107.         for (j = 0; j < col; j++)
  108.         {
  109.             if (board[i][j] == ' ')
  110.                 return 0;
  111.         }
  112.     }
  113.     return 1;
  114. }
  115.  
  116. char ISWIN(char board[ROW][COL], int row, int col)
  117. {
  118.     int i = 0, j = 0;
  119.  
  120.     for (i = 0; i < row; i++)
  121.     {
  122.         for (j = 0; j < col - 2; j++)
  123.         {
  124.             //判断横行
  125.             if (board[i][j] == board[i][j + 1] && board[i][j] == board[i][j + 2] && board[i][j] != ' ')
  126.                 return board[i][j];
  127.             //判断主对角线
  128.             else if (board[i][j] == board[i + 1][j + 1] && board[i + 2][j + 2] == board[i][j] && board[i][j] != ' ')
  129.                 return board[i][j];
  130.             //判断副对角线
  131.             else if (board[col - 1 - i][j] == board[col - 2 - i][j + 1] && board[col - 3 - i][j + 2] == board[col - 1 - i][j] && board[col - 1 - i][j] != ' ')
  132.                 return board[col - 1 - i][j];
  133.         }
  134.     }
  135.     for (i = 0; i < row - 2; i++)
  136.     {
  137.         for (j = 0; j < col; j++)
  138.         {
  139.             //判断竖行
  140.             if (board[i][j] == board[i + 1][j] && board[i][j] == board[i + 2][j] && board[i][j] != ' ')
  141.                 return board[i][j];
  142.         }
  143.     }
  144.  
  145.     //判断是否满盘---放在最后是因为最后一步的判断
  146.     if (1 == ISFULL(board, row, col))
  147.     {
  148.         return 'F';
  149.     }
  150.     return 'C';
  151. }

game.c

  1. #define _CRT_SECURE_NO_WARNINGS 1//加这一句话是因为笔者采用的是 VS 编译器，为了防止一些不必要的错误出现
  2.  
  3. #include "game.h"
  4.  
  5. void menu()//列出可供玩家选择的模式
  6. {
  7.     printf("**************************************************************\n");
  8.     printf("*****************         1.play              ****************\n");
  9.     printf("*****************         0.exit              ****************\n");
  10.     printf("**************************************************************\n");
  11. }
  12.  
  13. void play()
  14. {
  15.     int ret;
  16.     char board[ROW][COL] = { 0 };
  17.     InitBoard(board, ROW, COL);
  18.  
  19.     DisplayBoard(board, ROW, COL);
  20.     while (1)
  21.     {
  22.         PlayerMove(board, ROW, COL);
  23.         DisplayBoard(board, ROW, COL);
  24.         ret = ISWIN(board, ROW, COL);
  25.         {
  26.             if (ret != 'C')
  27.                 break;
  28.         }
  29.  
  30.         ComputerMove(board, ROW, COL);
  31.         DisplayBoard(board, ROW, COL);
  32.         ret = ISWIN(board, ROW, COL);
  33.         {
  34.             if (ret != 'C')
  35.                 break;
  36.         }
  37.     }
  38.     switch (ret)
  39.     {
  40.         case 'F':
  41.             printf("和局！\n");
  42.             system("pause");
  43.             system("cls");
  44.             break;
  45.         case '#':
  46.             printf("电脑赢！\n");
  47.             system("pause");
  48.             system("cls");
  49.             break;
  50.         case '*':
  51.             printf("玩家赢！\n");
  52.             system("pause");
  53.             system("cls");
  54.             break;
  55.         default:
  56.             break;
  57.     }
  58. }
  59.  
  60. int main()
  61. {
  62.     srand((unsigned)time(NULL));//随机种子的初始化
  63.     int input;//在这里，我们利用玩家选择的模式来控制循环的终止
  64.     do
  65.     {
  66.         menu();
  67.         printf("请输入你的选择：");
  68.         scanf("%d", &input);
  69.         switch (input)
  70.         {
  71.         case 1://play
  72.             system("cls");
  73.             play();
  74.             break;
  75.         case 0://退出
  76.             printf("欢迎下次再来！\n");
  77.             break;
  78.         default://当玩家输入了非法字符，让其重新选择
  79.             system("cls");
  80.             printf("输入错误，请重新输入！\n");
  81.         }
  82.     } while (input);//当input为0时，停止循环
  83.  
  84.     return 0;
  85. }

test.c

三.扩展

1.五子棋的实现

五子棋的实现仅仅只改变了判断规则，其它方式都没变。

判断代码：

  1. char ISWIN(char board[ROW][COL], int row, int col)
  2. {
  3.     int i = 0, j = 0;
  4.  
  5.     for (i = 0; i < col; i++)
  6.     {
  7.         for (j = 0; j < col - 4; j++)
  8.         {
  9.             //判断横行
  10.             if (board[i][j] == board[i][j + 1] && board[i][j] == board[i][j + 2] && board[i][j] == board[i][j + 3] && board[i][j] == board[i][j + 4] && board[i][j] != ' ')
  11.                 return board[i][j];
  12.             //判断对角线
  13.             else if (board[i][j] == board[i + 1][j + 1] && board[i + 2][j + 2] == board[i][j] && board[i][j] == board[i + 3][j + 3] && board[i][j] == board[i + 4][j + 4] && board[i][j] != ' ')
  14.                 return board[i][j];
  15.             else if (board[col - 1 - i][j] == board[col - 2 - i][j + 1] && board[col - 3 - i][j + 2] == board[col - 1 - i][j] && board[col - 4 - i][j + 3] == board[col - 2 - i][j + 1] && board[col - 5 - i][j + 4] == board[col - 2 - i][j + 1] && board[col - 1 - i][j] != ' ')
  16.                 return board[col - 1 - i][j];
  17.         }
  18.     }
  19.     for (i = 0; i < col - 4; i++)
  20.     {
  21.         for (j = 0; j < col ; j++)
  22.         {
  23.             //判断竖行
  24.             if (board[i][j] == board[i + 1][j] && board[i][j] == board[i + 2][j] && board[i][j] == board[i + 3][j] && board[i][j] == board[i + 4][j] && board[i][j] != ' ')
  25.                 return board[i][j];
  26.         }
  27.     }
  28.     //判断是否满盘
  29.     if (1 == ISFULL(board, row, col))
  30.     {
  31.         return 'f';
  32.     }
  33.  
  34.     return 'c';
  35. }

2.玩家对战玩家

只需将电脑下子的部分，替换成玩家下子即可

完整五子棋-人人对战代码：

  1. #pragma once
  2. #include <stdio.h>
  3. #include<stdlib.h>
  4. #include<time.h>
  5. #include<Windows.h>
  6.  
  7. #define ROW 10
  8. #define COL 10
  9.  
  10. //初始化棋盘
  11. void InitBoard(char board[ROW][COL], int row, int col);
  12.  
  13. //打印棋盘
  14. void DisplayBoard(char board[ROW][COL], int row, int col);
  15.  
  16. //玩家走
  17. void Player1Move(char board[ROW][COL],int row, int col);
  18.  
  19. //玩家2走
  20. void Player2Move(char board[ROW][COL], int row, int col);
  21.  
  22. //电脑走
  23. void ComputerMove(char board[ROW][COL], int row, int col);
  24.  
  25. //判断输赢
  26. char ISWIN(char board[ROW][COL], int row, int col);
  27.  
  28. //判断棋盘是否已满
  29. int ISFULL(char board[ROW][COL], int row, int col);

game.h

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include "game.h"
  3.  
  4. void InitBoard(char board[ROW][COL], int row, int col)
  5. {
  6.     int i = 0, j = 0;
  7.     for (i = 0; i < row; i++)
  8.     {
  9.         for (j = 0; j < col; j++)
  10.         {
  11.             board[i][j] = ' ';
  12.         }
  13.     }
  14. }
  15.  
  16. void DisplayBoard(char board[ROW][COL], int row, int col)
  17. {
  18.     int i = 0, j = 0;
  19.     for (i = 0; i < col; i++)
  20.         printf("   %d", i + 1);
  21.     printf("\n");
  22.     for (i = 0; i < row; i++)
  23.     {
  24.         printf("%2d", i + 1);
  25.         for (j = 0; j < col; j++)
  26.         {
  27.             printf(" %c ",board[i][j]);
  28.             if (j < col - 1)
  29.                 printf("|");
  30.         }
  31.         printf("\n");
  32.  
  33.         //打印分割行
  34.         if (i < row - 1)
  35.         {
  36.             printf("  ");
  37.             for (j = 0; j < col; j++)
  38.             {
  39.                 printf("---");
  40.                 if (j < col - 1)
  41.                     printf("|");
  42.             }
  43.             printf("\n");
  44.         }
  45.     }
  46. }
  47.  
  48. void Player1Move(char board[ROW][COL], int row, int col)
  49. {
  50.     int i = 0, j = 0;
  51.     while (1)
  52.     {
  53.         printf("请输入玩家1要下的棋的坐标：");
  54.         scanf("%d%d", &i, &j);
  55.         //检查是否越界
  56.         if (1 <= i && i <= row && j >= 1 && j <= col)
  57.         {
  58.             if (board[i-1][j-1] != ' ')
  59.                 printf("此坐标已被占用！\n");
  60.             else
  61.             {
  62.                 board[i-1][j-1] = '*';
  63.                 break;
  64.             }
  65.         }
  66.         else
  67.             printf("坐标非法访问！\n");
  68.     }
  69.     system("cls");
  70. }
  71.  
  72. void Player2Move(char board[ROW][COL], int row, int col)
  73. {
  74.     int i = 0, j = 0;
  75.     while (1)
  76.     {
  77.         printf("请输入玩家2要下的棋的坐标：");
  78.         scanf("%d%d", &i, &j);
  79.         //检查是否越界
  80.         if (1 <= i && i <= row && j >= 1 && j <= col)
  81.         {
  82.             if (board[i - 1][j - 1] != ' ')
  83.                 printf("此坐标已被占用！\n");
  84.             else
  85.             {
  86.                 board[i - 1][j - 1] = '#';
  87.                 break;
  88.             }
  89.         }
  90.         else
  91.             printf("坐标非法访问！\n");
  92.     }
  93.     system("cls");
  94. }
  95.  
  96. //void ComputerMove(char board[ROW][COL], int row, int col)
  97. //{
  98. //    int i = 0, j = 0;
  99. //    printf("电脑走：\n");
  100. //    while (1)
  101. //    {
  102. //        i = rand() % row;
  103. //        j = rand() % col;
  104. //        if (board[i][j] == ' ')
  105. //        {
  106. //            board[i][j] = '#';
  107. //            break;
  108. //        }
  109. //    }
  110. //    Sleep(1000);
  111. //    system("cls");
  112. //}
  113.  
  114. int ISFULL(char board[ROW][COL], int row, int col)
  115. {
  116.     int i = 0, j = 0;
  117.     for (i = 0; i < row; i++)
  118.     {
  119.         for (j = 0; j < col; j++)
  120.         {
  121.             if (board[i][j] == ' ')
  122.                 return 0;
  123.         }
  124.     }
  125.     return 1;
  126. }
  127.  
  128. char ISWIN(char board[ROW][COL], int row, int col)
  129. {
  130.     int i = 0, j = 0;
  131.  
  132.     for (i = 0; i < col; i++)
  133.     {
  134.         for (j = 0; j < col - 4; j++)
  135.         {
  136.             //判断横行
  137.             if (board[i][j] == board[i][j + 1] && board[i][j] == board[i][j + 2] && board[i][j] == board[i][j + 3] && board[i][j] == board[i][j + 4] && board[i][j] != ' ')
  138.                 return board[i][j];
  139.             //判断对角线
  140.             else if (board[i][j] == board[i + 1][j + 1] && board[i + 2][j + 2] == board[i][j] && board[i][j] == board[i + 3][j + 3] && board[i][j] == board[i + 4][j + 4] && board[i][j] != ' ')
  141.                 return board[i][j];
  142.             else if (board[col - 1 - i][j] == board[col - 2 - i][j + 1] && board[col - 3 - i][j + 2] == board[col - 1 - i][j] && board[col - 4 - i][j + 3] == board[col - 2 - i][j + 1] && board[col - 5 - i][j + 4] == board[col - 2 - i][j + 1] && board[col - 1 - i][j] != ' ')
  143.                 return board[col - 1 - i][j];
  144.         }
  145.     }
  146.     for (i = 0; i < col - 4; i++)
  147.     {
  148.         for (j = 0; j < col ; j++)
  149.         {
  150.             //判断竖行
  151.             if (board[i][j] == board[i + 1][j] && board[i][j] == board[i + 2][j] && board[i][j] == board[i + 3][j] && board[i][j] == board[i + 4][j] && board[i][j] != ' ')
  152.                 return board[i][j];
  153.         }
  154.     }
  155.     //判断是否满盘
  156.     if (1 == ISFULL(board, row, col))
  157.     {
  158.         return 'f';
  159.     }
  160.  
  161.     return 'c';
  162. }

game.c

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include"game.h"
  3.  
  4. void menu()
  5. {
  6.     printf("*********************************************\n");
  7.     printf("*******             1.play          *********\n");
  8.     printf("*******             0.quit          *********\n");
  9.     printf("*********************************************\n");
  10. }
  11.  
  12. int choice()
  13. {
  14.     int input = 0;
  15.     printf("请输入你的选择：");
  16.     scanf("%d", &input);
  17.     return input;
  18. }
  19.  
  20. void game()
  21. {
  22.     char ret;
  23.     char board[ROW][COL] = { 0 };
  24.     InitBoard(board, ROW, COL);
  25.     DisplayBoard(board, ROW, COL);
  26.     while (1)
  27.     {
  28.         Player1Move(board, ROW, COL);
  29.  
  30.         DisplayBoard(board, ROW, COL);
  31.  
  32.         ret = ISWIN(board, ROW, COL);
  33.         {
  34.             if (ret != 'c')
  35.                 break;
  36.         }
  37.  
  38.         Player2Move(board, ROW, COL);
  39.  
  40.         DisplayBoard(board, ROW, COL);
  41.  
  42.         ret = ISWIN(board, ROW, COL);
  43.         {
  44.             if (ret != 'c')
  45.                 break;
  46.         }
  47.     }
  48.     switch (ret)
  49.     {
  50.     case 'f':
  51.         printf("和局！\n");
  52.         break;
  53.     case '#':
  54.         //printf("电脑赢！\n");
  55.         printf("玩家2赢！\n");
  56.         break;
  57.     case '*':
  58.         printf("玩家1赢！\n");
  59.         break;
  60.     default:
  61.         break;
  62.     }
  63. }
  64.  
  65. void play()
  66. {
  67.     int input;
  68.     do
  69.     {
  70.         menu();
  71.         input = choice();
  72.         system("cls");
  73.         switch (input)
  74.         {
  75.         case 1:
  76.             game();
  77.             break;
  78.         case 0:
  79.             printf("谢谢使用，欢迎下次再来！\n");
  80.             break;
  81.         default:
  82.             system("cls");
  83.             printf("输入错误，请重新输入！\n");
  84.             break;
  85.         }
  86.     } while (input);
  87. }
  88.  
  89. int main()
  90. {
  91.     play();
  92.     return 0;
  93. }

test.c

3.电脑下棋的探究

对此我们的算法肯定是需要极大的改进的

建议：

　　1.不在用随机函数代替机器大脑

　　2.电脑根据情况堵截

关于三子棋的讲解便到此为止。

笔者水平有限，若有错误之处，还望多多指正。

C语言之三字棋的简单实现及扩展的更多相关文章

  1. C语言实现简单php自定义扩展

    1.下载php源码 下载地址:http://cn2.php.net/get/php-5.6.29.tar.gz/from/this/mirror 传到/usr/local/src/下 上传命令:rz ...

  2. GO语言练习：实现最简单的http helloword 服务器

    用Go语言实现一个最简单的http服务器端,主要用到了package io, log, net/http 这个3个库. 用到的函数包括: http.Handle() http.HandlerFunc( ...

  3. C语言开发CGI程序的简单例子

    这年头用C语言开发cgi的已经不多,大多数的web程序都使用java.php.python等这些语言了. 但是本文将做一些简单的cgi实例. 首先配置环境 #这里是使用的apache AddHandl ...

  4. 【笔记】嵩天.Python语言程序设计.完成两个简单实例（温度转换和绘图）

    [博客导航] [Python相关] 目标 使用PyCharm,完成两个小实例的编写和运行.一个是温度转换,一个是蟒蛇图形绘制. 过程 1.先设置project目录,虽然命名不是很正式,主要不太习惯软件 ...

  5. 函数式语言（Functional language）简单介绍

    函数式语言(functional language)一类程序设计语言,是一种非冯·诺伊曼式的程序设计语言.函数式语言主要成分是原始函数.定义函数和函数型. 函数式语言有:Haskell,Clean,M ...

  6. C语言程序设计（三） 简单的算术运算和表达式

    第三章 简单的算术运算和表达式 算数运算符:一元.二元.三元(条件运算符) 1/2是整型除法,1.0/2是浮点数除法 求余运算(%)限定参与运算的两个操作数必须为整数,不能对两个实型数据进行求余运算 ...

  7. 适合刚刚学习编程的萌新：C语言编程学习制作超简单又好玩的报数游戏！

    C语言是面向过程的,而C++是面向对象的 C和C++的区别: C是一个结构化语言,它的重点在于算法和数据结构.C程序的设计首要考虑的是如何通过一个过程,对输入(或环境条件)进行运算处理得到输出(或实现 ...

  8. C语言中如何写一个简单可移植而又足够随机的随机数生成器

    在C语言中标准库中的随机数产生函数的返回可能不是最优的,因为有些随机数生成器的低位并不随机,而另一些返回随机数的函数实现上又太复杂鸟.所以rand()%N并不是一个好方法,牛人给出的建议是使用: ra ...

  9. 用c语言实现三子棋

    1 game.c://实现三子棋的.c文件 #define _CRT_SECURE_NO_WARNINGS #include"game.h" void init_board(cha ...

随机推荐

  1. leetcode 122 123 309 188 714 股票买卖 动态规划

    这类问题有一个通法 https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iii/solution/yi-ge-tong-y ...

  2. codeforces 8B

    B. Obsession with Robots time limit per test 2 seconds memory limit per test 64 megabytes input stan ...

  3. Leetcode（106）-从中序与后序遍历序列构造二叉树

    根据一棵树的中序遍历与后序遍历构造二叉树. 注意:你可以假设树中没有重复的元素. 例如,给出 中序遍历 inorder = [9,3,15,20,7] 后序遍历 postorder = [9,15,7 ...

  4. μC/OS-III---I笔记12---任务管理

    任务管理任务切换应该算是UCOS最基本的部分,首先保存当前任务寄存器的内容到当前任务的堆栈:接着弹出即将进行的任务的堆栈内容到寄存器中然后就是按寄存器内容执行,这个过程成为上下文切换.任务堆栈在创建任 ...

  5. Windows font-size: 10px; bug

    Windows font-size: 10px; bug Windows 最小只能渲染 font-size: 12px; ???屏幕分辨率 macOS 正常渲染 10px PC 最小只能渲染 font ...

  6. css position sticky All In One

    css position sticky All In One css sticky & 吸顶效果 demo https://codepen.io/xgqfrms/pen/PoqyVYz ref ...

  7. Jamstack Conf 2020

    Jamstack Conf 2020 Jamstack Conf Virtual https://jamstackconf.com/virtual/ Conf Schedule https://jam ...

  8. JavaScript Inheritance All in One

    JavaScript Inheritance All in One constructor inheritance prototype chain inheritance "use stri ...

  9. http methods & restful api methods

    http methods & restful api methods 超文本传输​​协议(HTTP)是用于传输超媒体文档(例如HTML)的应用层协议 https://developer.moz ...

  10. 漫画 | C语言哭了，过年回家，只有我还没对象

    C语言回家过年,遇到不少小伙伴. 大家都在外地打拼,一年难得见面,聚到一起吃饭,都非常高兴. 听Java提到TIOBE, 正在喝酒的C语言激动起来. 自己常年在那里排名第二,人类用自己写的程序可真不少 ...