用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 函数是程序的入口。它使用一个无限循环，每次循环轮流让玩家下子，然后判断是否游戏结束。如果有一方获胜或者棋盘已满，则打印相应的信息，并结束游戏。

开始写代码

void printBoard() {
    for (int i = 0; i < BOARD_SIZE; i++) {
        for (int j = 0; j < BOARD_SIZE; j++) {
            cout << board[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;
}

 

这段代码为打印棋盘状态的函数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的棋子。通过这个函数，可以直观地展示游戏棋盘的状态给玩家。

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

 

这段代码是用于判断玩家落子是否合法的函数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。

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

 

bool checkWin(int row, int col, char player) {
    int directions[4][2] = {{1, 0}, {0, 1}, {1, 1}, {-1, 1}};
    for (int i = 0; i < 4; i++) {
        int count = 1;
        int dx = directions[i][0], dy = directions[i][1];
        int r = row + dx, c = col + dy;
        while (r >= 0 && r < BOARD_SIZE && c >= 0 && c < BOARD_SIZE && board[r][c] == player) {
            count++;
            r += dx;
            c += dy;
        }
        dx = -dx, dy = -dy;
        r = row + dx, c = col + dy;
        while (r >= 0 && r < BOARD_SIZE && c >= 0 && c < BOARD_SIZE && board[r][c] == player) {
            count++;
            r += dx;
            c += dy;
        }
        if (count >= 5)
            return true;
    }
    return false;
}

 

这段代码是用于检查玩家是否取得胜利的函数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。

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

完整代码 

#include <iostream>
#include <vector>

using namespace std;

const int BOARD_SIZE = 15;
const char EMPTY = '-';
const char BLACK = 'X';
const char WHITE = 'O';

vector<vector<char> > board(BOARD_SIZE, vector<char>(BOARD_SIZE, EMPTY));

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

bool checkWin(int row, int col, char player) {
    int directions[4][2] = {{1, 0}, {0, 1}, {1, 1}, {-1, 1}};
    for (int i = 0; i < 4; i++) {
        int count = 1;
        int dx = directions[i][0], dy = directions[i][1];
        int r = row + dx, c = col + dy;
        while (r >= 0 && r < BOARD_SIZE && c >= 0 && c < BOARD_SIZE && board[r][c] == player) {
            count++;
            r += dx;
            c += dy;
        }
        dx = -dx, dy = -dy;
        r = row + dx, c = col + dy;
        while (r >= 0 && r < BOARD_SIZE && c >= 0 && c < BOARD_SIZE && board[r][c] == player) {
            count++;
            r += dx;
            c += dy;
        }
        if (count >= 5)
            return true;
    }
    return false;
}

void printBoard() {
    for (int i = 0; i < BOARD_SIZE; i++) {
        for (int j = 0; j < BOARD_SIZE; j++) {
            cout << board[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;
}

bool isBoardFull() {
    for (int i = 0; i < BOARD_SIZE; i++) {
        for (int j = 0; j < BOARD_SIZE; j++) {
            if (board[i][j] == EMPTY)
                return false;
        }
    }
    return true;
}

int main() {
    int row, col;
    char currentPlayer = BLACK;

    while (true) {
        printBoard();

        cout << "Player " << currentPlayer << ", enter your move (row col): ";
        cin >> row >> col;

        if (!isValidMove(row, col)) {
            cout << "Invalid move! Try again." << endl;
            continue;
        }

        board[row][col] = currentPlayer;

        if (checkWin(row, col, currentPlayer)) {
            cout << "Player " << currentPlayer << " wins!" << endl;
            break;
        } else if (isBoardFull()) {
            cout << "It's a draw!" << endl;
            break;
        }

        currentPlayer = (currentPlayer == BLACK) ? WHITE : BLACK;
    }

    printBoard();
    return 0;
}

 

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

输入：

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

输出：

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

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

结果图：

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