数组应用-三子棋-CSDN博客

本文链接：https://blog.csdn.net/qq_59805046/article/details/147072727

应用实例

利用数组实现三子棋
模块化实现
test.c //测试游戏的逻辑
game.c //游戏代码的实现
game.h //游戏代码的声明（函数声明，符号定义）

#include <stdlib.h>
#include <time.h>

//打印菜单
void menu()
{
   printf("******************************\n");
   printf("**********1. play ************\n");
   printf("**********0. exit ************\n");
   printf("******************************\n");
}

//初始化棋盘
#define ROW 3
#define COL 3// 方便以后改为五子棋之类的
void initboard(char board[ROW][COL], int row, int col)
{
   int i = 0;
   int j = 0;
   for (i = 0; i < row; i++)
   {
       for (j = 0; j < col; j++)
       {
           board[i][j] = ' ';
       }
   }
}

//打印棋盘第一个版本，因为只能打印3列，以后不好改五子棋

/*void displayboard(char board[ROW][COL], int row, int col)
{
   int i = 0;
   for (i = 0; i < row; i++)
   {
       //打印数据
       printf(" %c | %c | %c \n", board[i][0], board[i][1], board[i][2]);
       //打印分割行
       if(i<row-1)
       printf("---|---|---\n");
   }
}*/

//打印棋盘第二个版本
void displayboard(char board[ROW][COL], int row, int col)
{
   int i = 0;
   for (i = 0; i < row; i++)
   {
       //打印数据
       int j = 0;
       for (j = 0; j < col; j++)
       {
           printf(" %c ", board[i][j]);
           if (j < col - 1)
               printf("|");
       }
       printf("\n");
       //打印分割行
       if (i < row - 1)
       {
           int j = 0;
           for (j = 0; j < col; j++)
           {
               printf("---");
               if (j < col - 1)
                   printf("|");
           }
           printf("\n");
       }
   }
}

//玩家下棋
void playermove(char board[ROW][COL], int row, int col)
{
   int x = 0;
   int y = 0;
   printf("玩家下棋:>\n");

   while (1)
   {
       printf("请输入坐标:>");
       scanf("%d %d", &x, &y);
       while (getchar() != '\n')
       {
           ;
       }//清理缓冲区，getchar 函数会从输入缓冲区中读取一个字符，并返回该字符的 ASCII 码值直到读取到\n
       //坐标范围合法的判断
       if (x >= 1 && x <= row && y >= 1 && y <= col)
       {
           if (board[x - 1][y - 1] == ' ')
           {
               board[x - 1][y - 1] = '*';
               break;
           }
           else
           {
               printf("坐标被占用，请选择其它位置\n");
           }
       }
       else
       {
           printf("坐标非法，请重新输入\n");
       }
   }
}

//电脑下棋
//找没有下棋的空白位置随机下棋
void computermove(char board[ROW][COL], int row, int col)
{
   printf("电脑下棋:>\n");
   int x = 0;
   int y = 0;
   while (1)
   {
       x = rand() % row;//0~2
       y = rand() % col;//0~2
       if (board[x][y] == ' ')
       {
           board[x][y] = '#';
           break;
       }
   }
}

// 判断棋盘是否满
//如果满了返回1，不满返回0
int isfull(char board[ROW][COL], int row, int col)
{
   int i = 0;
   int j = 0;
   for (i = 0; i < row; i++)
   {
       for (j = 0; j < col; j++)
       {
           if (board[i][j] == ' ')
           {
               return 0;
           }
       }
   }
   return 1;
}

//玩家赢 - '*'
//电脑赢 - '#'
//平局 - 'Q'
//游戏继续 - 'C'
//只有这四种状态,约定好返回值
//判断是否赢
char iswin(char board[ROW][COL], int row, int col)
{
   //先判断行
   int i = 0;
   for (i = 0; i < row; i++)
   {
       if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][1] != ' ')
       {
           return board[i][1];
       }
   }
   //再判断列
   int j = 0;
   for (j = 0; j < col; j++)
   {
       if (board[0][j] == board[1][j] && board[1][j] == board[2][j] && board[1][j] != ' ')
       {
           return board[1][j];
       }
   }
   //最后判断对角线
   if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
   {
       return board[1][1];
   }
   if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[1][1] != ' ')
   {
       return board[1][1];
   }
   //如果走到这，那么没有人赢，就要平局
   if (isfull(board, row, col))
   {
       return 'Q';
   }
   //游戏继续
   return 'C';
}

//主游戏函数
void game()
{
   char board[ROW][COL] = { 0 };
   //初始化棋盘的函数
   initboard(board, ROW, COL);
   //打印棋盘函数
   displayboard(board, ROW, COL);
   //下棋
   int ret = 0;
   while (1)
   {
       playermove(board, ROW, COL);
       //判断输赢
       ret = iswin(board, ROW, COL);
       if (ret != 'C')
       {
           break;
       }

       displayboard(board, ROW, COL);
       computermove(board, ROW, COL);
       //判断输赢
       ret = iswin(board, ROW, COL);
       if (ret != 'C')
       {
           break;
       }
       displayboard(board, ROW, COL);
   }
   if (ret == '*')
   {
       printf("玩家赢了！\n");
   }
   else if (ret == '#')
   {
       printf("电脑赢了\n");
   }
   else
   {
       printf("平局\n");
   }
   displayboard(board, ROW, COL);
}

//主函数
int main()
{
srand((unsigned int)time(NULL));//设置随机数的生成起点

   int input = 0;
   do
   {
       menu();//打印菜单
       printf("请选择:>");
       scanf("%d", &input);
       while (getchar() != '\n')
       {
           ;
       }
       switch (input)
       {
       case 1:
           game();
           break;
       case 0:
           printf("退出游戏\n");
           break;
       default:
           printf("选择错误，请重新选择\n");
           break;
       }
   } while (input);
   return 0;
}

整理一下：

1. 头文件和宏定义部分

#include <stdlib.h>
#include <time.h>
#define ROW 3
#define COL 3

头文件：
stdlib.h：提供了像 rand、srand 这类用于随机数生成的函数。
time.h：提供了 time 函数，可用于获取当前时间，为随机数生成设置种子。

宏定义：
ROW 和 COL 定义了棋盘的行数和列数，这里设定为3，后续若要改成五子棋等其他游戏，修改这两个宏定义的值即可。

2. 菜单函数 menu

void menu()
{
   printf("******************************\n");
   printf("**********1. play ************\n");
   printf("**********0. exit ************\n");
   printf("******************************\n");
}

此函数的作用是打印游戏菜单，给出两个选项：开始游戏（输入 1）和退出游戏（输入 0）。

3. 初始化棋盘函数 initboard

void initboard(char board[ROW][COL], int row, int col)
{
   int i = 0;
   int j = 0;
   for (i = 0; i < row; i++)
   {
       for (j = 0; j < col; j++)
       {
           board[i][j] = ' ';
       }
   }
}

该函数接收一个二维字符数组 board 以及行数 row 和列数 col 作为参数。
借助双重循环，把棋盘的每个位置初始化为空格字符 ' '，表示该位置未被占用。

4. 打印棋盘函数 displayboard

void displayboard(char board[ROW][COL], int row, int col)
{
   int i = 0;
   for (i = 0; i < row; i++)
   {
       //打印数据
       int j = 0;
       for (j = 0; j < col; j++)
       {
           printf(" %c ", board[i][j]);
           if (j < col - 1)
               printf("|");
       }
       printf("\n");
       //打印分割行
       if (i < row - 1)
       {
           int j = 0;
           for (j = 0; j < col; j++)
           {
               printf("---");
               if (j < col - 1)
                   printf("|");
           }
           printf("\n");
       }
   }
}

该函数接收一个二维字符数组 board 以及行数 row 和列数 col 作为参数。
利用双重循环打印棋盘，每一行的数据用空格分隔，相邻列的数据用竖线 | 分隔，行与行之间用横线-- - 分隔。

5. 玩家下棋函数 playermove

void playermove(char board[ROW][COL], int row, int col)
{
   int x = 0;
   int y = 0;
   printf("玩家下棋:>\n");

   while (1)
   {
       printf("请输入坐标:>");
       scanf("%d %d", &x, &y);
       while (getchar() != '\n')
       {
           ;
       }
       //坐标范围合法的判断
       if (x >= 1 && x <= row && y >= 1 && y <= col)
       {
           if (board[x - 1][y - 1] == ' ')
           {
               board[x - 1][y - 1] = '*';
               break;
           }
           else
           {
               printf("坐标被占用，请选择其它位置\n");
           }
       }
       else
       {
           printf("坐标非法，请重新输入\n");
       }
   }
}

该函数接收一个二维字符数组 board 以及行数 row 和列数 col 作为参数。
进入一个无限循环，提示玩家输入下棋的坐标。
运用 scanf 读取玩家输入的坐标，然后使用 while (getchar() != '\n') 清理输入缓冲区，防止多余字符影响后续输入。
检查坐标是否在合法范围内（1 到 row 和 1 到 col 之间），并且该位置是否未被占用。若满足条件，将该位置标记为 * 表示玩家下棋，然后跳出循环；否则，提示玩家重新输入。

6. 电脑下棋函数 computermove

void computermove(char board[ROW][COL], int row, int col)
{
   printf("电脑下棋:>\n");
   int x = 0;
   int y = 0;
   while (1)
   {
       x = rand() % row;
       y = rand() % col;
       if (board[x][y] == ' ')
       {
           board[x][y] = '#';
           break;
       }
   }
}

该函数接收一个二维字符数组 board 以及行数 row 和列数 col 作为参数。
进入一个无限循环，使用 rand 函数生成随机的坐标 x 和 y。
检查该位置是否未被占用，若未被占用，将该位置标记为 # 表示电脑下棋，然后跳出循环。

7. 判断棋盘是否已满函数 isfull

int isfull(char board[ROW][COL], int row, int col)
{
   int i = 0;
   int j = 0;
   for (i = 0; i < row; i++)
   {
       for (j = 0; j < col; j++)
       {
           if (board[i][j] == ' ')
           {
               return 0;
           }
       }
   }
   return 1;
}

该函数接收一个二维字符数组 board 以及行数 row 和列数 col 作为参数。
利用双重循环遍历棋盘的每个位置，若发现有未被占用的位置（值为 ' '），则返回 0 表示棋盘未满；若所有位置都被占用，返回 1 表示棋盘已满。

8. 判断游戏胜负函数 iswin

char iswin(char board[ROW][COL], int row, int col)
{
   //先判断行
   int i = 0;
   for (i = 0; i < row; i++)
   {
       if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][1] != ' ')
       {
           return board[i][1];
       }
   }
   //再判断列
   int j = 0;
   for (j = 0; j < col; j++)
   {
       if (board[0][j] == board[1][j] && board[1][j] == board[2][j] && board[1][j] != ' ')
       {
           return board[1][j];
       }
   }
   //最后判断对角线
   if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
   {
       return board[1][1];
   }
   if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[1][1] != ' ')
   {
       return board[1][1];
   }
   //如果走到这，那么没有人赢，就要平局，判断是否满
   if (isfull(board, row, col))
   {
       return 'Q';
   }
   //游戏继续
   return 'C';
}

该函数接收一个二维字符数组 board 以及行数 row 和列数 col 作为参数。
先逐行检查是否有三个相同且非空的字符，若有则返回该字符，表示该行对应的玩家获胜。
接着逐列检查是否有三个相同且非空的字符，若有则返回该字符，表示该列对应的玩家获胜。
然后检查两条对角线是否有三个相同且非空的字符，若有则返回该字符，表示该对角线对应的玩家获胜。
若没有玩家获胜，检查棋盘是否已满，若已满则返回 'Q' 表示平局；否则返回 'C' 表示游戏继续。

9. 游戏主函数 game

void game()
{
   char board[ROW][COL] = { 0 };
   //初始化棋盘的函数
   initboard(board, ROW, COL);
   //打印棋盘函数
   displayboard(board, ROW, COL);
   //下棋
   int ret = 0;
   while (1)
   {
       playermove(board, ROW, COL);
       //判断输赢
       ret = iswin(board, ROW, COL);
       if (ret != 'C')
       {
           break;
       }

该函数是游戏的核心逻辑函数。
定义一个二维字符数组 board 表示棋盘，调用 initboard 函数初始化棋盘，调用 displayboard 函数打印初始棋盘。
进入一个无限循环，在循环中，玩家先下棋，调用 iswin 函数判断游戏结果，若游戏结束（返回值不是 'C'），则跳出循环；
否则，打印当前棋盘，电脑下棋，再次调用 iswin 函数判断游戏结果，若游戏结束则跳出循环。
根据 iswin 函数的返回值，输出游戏结果（玩家赢、电脑赢或平局），最后打印最终的棋盘。

10. 主函数 main

int main()
{
   srand((unsigned int)time(NULL));
   int input = 0;
   do
   {
       menu();
       printf("请选择:>");
       scanf("%d", &input);
       while (getchar() != '\n')
       {
           ;
       }
       switch (input)
       {
       case 1:
           game();
           break;
       case 0:
           printf("退出游戏\n");
           break;
       default:
           printf("选择错误，请重新选择\n");
           break;
       }
   } while (input);
   return 0;
}

调用 srand((unsigned int)time(NULL)) 函数，利用当前时间作为随机数种子，保证每次运行程序时电脑下棋的坐标是随机的。
使用 do - while 循环显示菜单，提示用户选择操作。
读取用户输入的选项，使用 while (getchar() != '\n') 清理输入缓冲区。
根据用户的选择，使用 switch 语句执行相应的操作：若选择 1，则调用 game 函数开始游戏；若选择 0，则输出退出信息并结束程序；若选择其他选项，则提示用户重新选择。
只要用户输入的选项不为 0，循环就会继续，直到用户选择退出游戏。