• 用c++实现五子棋小游戏

    五子棋是一款经典小游戏，今天我们就用c++实现简单的五子棋小游戏

    目录

    用到的算法：

    思路分析

    定义变量 

    开始写代码

     

    完整代码 

    结果图：

    用到的算法：

    1. 合法移动的判断：isValidMove 函数通过检查指定位置是否在棋盘范围内，并且该位置是否为空位来确定是否为合法的移动。

    2. 获胜条件的检查：checkWin 函数通过遍历四个方向（水平、垂直、两个对角线）来检查是否存在连续的五个相同类型的棋子。它使用两个 while 循环，一个向一个方向移动，另一个向相反方向移动，以统计横向、纵向和对角线上相同类型棋子的数量。

    3. 棋盘状态的打印：printBoard 函数使用嵌套的 for 循环来遍历棋盘的每个位置，并输出相应的符号来表示该位置的状态。

    4. 棋盘是否已满的检查：isBoardFull 函数使用嵌套的 for 循环来遍历棋盘的每个位置，检查是否存在空位。如果不存在空位，则棋盘已满

    思路分析

    1. 初始化：创建一个空的棋盘，大小为15x15，用二维向量表示。初始时所有位置都是空位。

    2. 循环游戏：进入一个无限循环，在每一轮中依次执行以下步骤：

      • 打印当前棋盘状态；
      • 根据当前轮到的玩家，提示玩家输入下子位置；
      • 检查输入的下子位置是否合法，即在棋盘范围内且为空位，如果不合法则提示重新输入；
      • 在棋盘上下子，并判断是否获胜或棋盘已满；
      • 如果获胜或棋盘已满，根据情况打印相应的信息，并结束游戏。

    3. 判断获胜和棋盘是否已满：

      • 每次下子后，调用 checkWin 函数来检查当前位置是否连成五子，如果是则返回获胜；
      • 如果没有获胜，则调用 isBoardFull 函数来判断棋盘是否已满，如果棋盘已满则返回平局。

    4. 输出棋盘状态：

      • printBoard 函数使用嵌套的 for 循环遍历棋盘的每个位置，根据该位置的状态输出相应的符号，用于展示当前棋盘状态

    定义变量 

    • BOARD_SIZE 定义了棋盘的大小，这里设置为15x15。
    • EMPTY、BLACK 和 WHITE 定义了棋盘上的三种状态：空位、黑棋和白棋。
    • board 是一个二维向量，表示棋盘，初始时所有位置都是空位。
    • isValidMove 函数用于判断某个位置是否可以下子。合法的位置必须在棋盘范围内，并且为空位。
    • checkWin 函数用于判断某个位置下子后是否获胜。它检查当前位置在四个方向上（水平、垂直、两个对角线）是否有连续的连续的五个相同类型棋子。如果有则返回 true，否则返回 false。
    • printBoard 函数用于打印当前棋盘的状态。
    • isBoardFull 函数用于判断棋盘是否已经满了（即没有空位），如果棋盘已满，则返回 true，否则返回 false。
    • main 函数是程序的入口。它使用一个无限循环，每次循环轮流让玩家下子，然后判断是否游戏结束。如果有一方获胜或者棋盘已满，则打印相应的信息，并结束游戏。

    开始写代码

    1. void printBoard() {
    2.     for (int i = 0; i < BOARD_SIZE; i++) {
    3.         for (int j = 0; j < BOARD_SIZE; j++) {
    4.             cout << board[i][j] << " ";
    5.         }
    6.         cout << endl;
    7.     }
    8.     cout << endl;
    9. }

     

    这段代码为打印棋盘状态的函数printBoard()，使用了嵌套的循环来遍历棋盘，并输出每个位置的状态。

    具体的实现逻辑如下：

    1. 外层循环for (int i = 0; i < BOARD_SIZE; i++)遍历棋盘的行数，从第一行开始到最后一行。
    2. 内层循环for (int j = 0; j < BOARD_SIZE; j++)遍历棋盘的列数，从第一列开始到最后一列。
    3. 在内层循环中，通过board[i][j]获取当前位置的状态值，并使用cout输出该状态值。
    4. 输出一个空格，以分隔不同位置的状态值。
    5. 内层循环结束后，通过cout << endl;输出换行符，以换行显示下一行的棋盘状态。
    6. 外层循环结束后，通过cout << endl;再次输出一个换行符，以在棋盘状态的输出之间添加空行。

    这样，调用printBoard()函数可以按照指定格式输出当前棋盘的状态。每个位置上的状态值可以是空格、X或O等字符，表示空位、玩家1和玩家2的棋子。通过这个函数，可以直观地展示游戏棋盘的状态给玩家。

    1. bool isValidMove(int row, int col) {
    2.     return (row >= 0 && row < BOARD_SIZE && col >= 0 && col < BOARD_SIZE && board[row][col] == EMPTY);
    3. }

     

    这段代码是用于判断玩家落子是否合法的函数isValidMove(row, col)，其中row和col分别表示玩家输入的坐标值。

    具体的实现逻辑如下：

    1. 首先，通过row >= 0 && row < BOARD_SIZE && col >= 0 && col < BOARD_SIZE判断玩家输入的坐标值是否在棋盘范围内。如果超出了棋盘范围，则此次落子不合法。
    2. 否则，通过board[row][col] == EMPTY判断该位置是否已有棋子（即状态值是否为EMPTY）。如果该位置上没有棋子，则此次落子合法，返回true。
    3. 如果该位置上已经有棋子，则此次落子不合法，返回false。

    通过这个函数，可以快速判断玩家输入的坐标是否合法。如果不合法，则需要提示玩家重新输入坐标；如果合法，则可以继续进行游戏。

     

    1.  
    2. bool checkWin(int row, int col, char player) {
    3.     int directions[4][2] = {{1, 0}, {0, 1}, {1, 1}, {-1, 1}};
    4.     for (int i = 0; i < 4; i++) {
    5.         int count = 1;
    6.         int dx = directions[i][0], dy = directions[i][1];
    7.         int r = row + dx, c = col + dy;
    8.         while (r >= 0 && r < BOARD_SIZE && c >= 0 && c < BOARD_SIZE && board[r][c] == player) {
    9.             count++;
    10.             r += dx;
    11.             c += dy;
    12.         }
    13.         dx = -dx, dy = -dy;
    14.         r = row + dx, c = col + dy;
    15.         while (r >= 0 && r < BOARD_SIZE && c >= 0 && c < BOARD_SIZE && board[r][c] == player) {
    16.             count++;
    17.             r += dx;
    18.             c += dy;
    19.         }
    20.         if (count >= 5)
    21.             return true;
    22.     }
    23.     return false;
    24. }

     

    这段代码是用于检查玩家是否取得胜利的函数checkWin(row, col, player)，其中row和col表示最后一次落子的坐标，player表示当前玩家的符号。

    具体的实现逻辑如下：

    1. 首先，定义一个二维数组directions[4][2]来表示四个方向，分别为向下、向右、右下、左下。每个方向由两个元素组成，分别表示在行方向和列方向上的增量。
    2. 使用一个循环遍历四个方向。
    3. 在循环内部，初始化一个计数器count为1，表示已经有一颗当前玩家的棋子。
    4. 根据当前方向的增量(dx, dy)，计算下一个检查的位置(r, c)，并检查该位置是否在棋盘范围内且值等于当前玩家的符号。
    5. 如果满足条件，将计数器count加1，并更新下一个位置(r, c)为当前位置加上增量(dx, dy)。
    6. 重复步骤4和步骤5，直到碰到越界或者不是当前玩家的棋子。
    7. 然后，将增量(dx, dy)取相反数，即改变方向。
    8. 再次计算下一个检查的位置(r, c)，并检查该位置是否在棋盘范围内且值等于当前玩家的符号。
    9. 如果满足条件，将计数器count加1，并更新下一个位置(r, c)为当前位置加上增量(dx, dy)。
    10. 重复步骤8和步骤9，直到碰到越界或者不是当前玩家的棋子。
    11. 检查计数器count是否大于等于5，如果是，则表示当前玩家在其中一个方向上取得了胜利，返回true。
    12. 如果四个方向都遍历完毕，仍未满足取胜条件，则返回false。

    通过这个函数，可以判断当前玩家是否在最后一次落子后取得了胜利。根据游戏规则，只有当任意一方在横、竖、斜对角线方向上连续五个棋子时才算获胜。

    完整代码 

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5.  
    6. const int BOARD_SIZE = 15;
    7. const char EMPTY = '-';
    8. const char BLACK = 'X';
    9. const char WHITE = 'O';
    10.  
    11. vectorchar> > board(BOARD_SIZE, vector<char>(BOARD_SIZE, EMPTY));
    12.  
    13. bool isValidMove(int row, int col) {
    14.     return (row >= 0 && row < BOARD_SIZE && col >= 0 && col < BOARD_SIZE && board[row][col] == EMPTY);
    15. }
    16.  
    17. bool checkWin(int row, int col, char player) {
    18.     int directions[4][2] = {{1, 0}, {0, 1}, {1, 1}, {-1, 1}};
    19.     for (int i = 0; i < 4; i++) {
    20.         int count = 1;
    21.         int dx = directions[i][0], dy = directions[i][1];
    22.         int r = row + dx, c = col + dy;
    23.         while (r >= 0 && r < BOARD_SIZE && c >= 0 && c < BOARD_SIZE && board[r][c] == player) {
    24.             count++;
    25.             r += dx;
    26.             c += dy;
    27.         }
    28.         dx = -dx, dy = -dy;
    29.         r = row + dx, c = col + dy;
    30.         while (r >= 0 && r < BOARD_SIZE && c >= 0 && c < BOARD_SIZE && board[r][c] == player) {
    31.             count++;
    32.             r += dx;
    33.             c += dy;
    34.         }
    35.         if (count >= 5)
    36.             return true;
    37.     }
    38.     return false;
    39. }
    40.  
    41. void printBoard() {
    42.     for (int i = 0; i < BOARD_SIZE; i++) {
    43.         for (int j = 0; j < BOARD_SIZE; j++) {
    44.             cout << board[i][j] << " ";
    45.         }
    46.         cout << endl;
    47.     }
    48.     cout << endl;
    49. }
    50.  
    51. bool isBoardFull() {
    52.     for (int i = 0; i < BOARD_SIZE; i++) {
    53.         for (int j = 0; j < BOARD_SIZE; j++) {
    54.             if (board[i][j] == EMPTY)
    55.                 return false;
    56.         }
    57.     }
    58.     return true;
    59. }
    60.  
    61. int main() {
    62.     int row, col;
    63.     char currentPlayer = BLACK;
    64.  
    65.     while (true) {
    66.         printBoard();
    67.  
    68.         cout << "Player " << currentPlayer << ", enter your move (row col): ";
    69.         cin >> row >> col;
    70.  
    71.         if (!isValidMove(row, col)) {
    72.             cout << "Invalid move! Try again." << endl;
    73.             continue;
    74.         }
    75.  
    76.         board[row][col] = currentPlayer;
    77.  
    78.         if (checkWin(row, col, currentPlayer)) {
    79.             cout << "Player " << currentPlayer << " wins!" << endl;
    80.             break;
    81.         } else if (isBoardFull()) {
    82.             cout << "It's a draw!" << endl;
    83.             break;
    84.         }
    85.  
    86.         currentPlayer = (currentPlayer == BLACK) ? WHITE : BLACK;
    87.     }
    88.  
    89.     printBoard();
    90.     return 0;
    91. }

     

    在这个五子棋游戏代码中，可以通过以下方式进行输入和输出：

    输入：

    1. 玩家输入下子位置：可以通过命令行提示玩家输入坐标，例如，要求玩家输入行和列的数字，表示下子位置的坐标。
    2. 其他玩家操作：例如，要求玩家输入指令来选择重新开始游戏或退出游戏。

    输出：

    1. 打印当前棋盘状态：使用嵌套的循环遍历棋盘，根据棋盘上每个位置的状态输出相应的符号，可以使用空格、X和O等字符来表示空位、玩家1和玩家2的棋子。
    2. 提示玩家操作：例如，提示玩家输入坐标来下子，或者提示玩家输入指令以进行其他操作。
    3. 游戏结果输出：当游戏结束时，根据游戏结果输出胜利者或者平局信息。
    4. 错误提示：如果玩家输入了无效的指令或下子位置，可以输出错误提示信息，要求玩家重新输入。

    在代码中，可以使用适当的输入函数，如input()来接收玩家输入，并使用适当的输出函数，如print()来输出信息到控制台。通过合理地组织输入和输出，可以实现与玩家的有效交互，并提供友好的游戏体验。

    结果图：

    如果想要更加华丽美观的代码，关注博主赞赏2元回复“五子棋华丽代码”即可。

  • 相关阅读:
    暑假算法7.28，Day27
    POJ1330最近公共祖先LCA
    【机器学习】基于卷积神经网络 CNN 的猫狗分类问题
    众筹DAO“枯萎”的缩影：曾拍下《沙丘》未出版手稿的Spice DAO解散
    核酸检测引发的思考，关于redis缓存穿透、击穿和雪崩的理解和解决方案
    Linux设备驱动之gpio-keys
    【JAVA】Java 常见的垃圾收集器有哪些？
    Batch Normalization推理验证
    Cloud Flare 添加谷歌镜像站（反向代理）
    MapReduce入门实战
  • 原文地址：https://blog.csdn.net/2201_75867204/article/details/132917246