人机对战 3x3 Tic Tac Toe 游戏：C++ 类实现

本程序使用 C++ 类实现了一个 3x3 棋盘的人机对战 Tic Tac Toe 游戏。用户可以选择先手还是后手，并选择棋子是'X'还是'O'。计算机将使用极小极大算法来选择最优的下棋位置。

程序功能

状态显示: 计算机可正确显示棋盘，给出提示信息和胜负判定。
用户选择: 用户可以选择是先下还是后下，并选择棋子是'X'还是'O'。
图形化输出: 每一步都用图形化方式顺序输出，例如

O * X
X X *
O * *

棋盘初始化: 棋盘初始化为（'*'表示空格）

* * *
* * *
* * *

棋盘大小设置: 完成上述功能后考虑灵活设置棋盘大小。
智能性: 程序使用极小极大算法提升计算机的智能性，并根据以下规则进行计分:
- 若已有'XX'，计 50 分
- 若已有'OO'，计 25 分
- 若已有'X*'，计 10 分
- 若已有'O*'，计 8 分
- 若已有'**'，计 4 分

C++ 代码实现

#include <iostream>
#include <vector>

using namespace std;

class TicTacToe {
private:
    vector<vector<char>> board;
    char player;
    char computer;

public:
    TicTacToe() {
        board.resize(3, vector<char>(3, '*'));
        player = ' ';
        computer = ' ';
    }

    void startGame() {
        cout << "Welcome to Tic Tac Toe!" << endl;
        cout << "Please choose 'X' or 'O': ";
        cin >> player;

        if (player == 'X' || player == 'x') {
            computer = 'O';
        } else if (player == 'O' || player == 'o') {
            computer = 'X';
        } else {
            cout << "Invalid input. Please choose 'X' or 'O'." << endl;
            return;
        }

        cout << "Do you want to play first? (Y/N): ";
        char choice;
        cin >> choice;

        if (choice == 'N' || choice == 'n') {
            computerMove();
            printBoard();
        }

        playGame();
    }

private:
    void playGame() {
        while (!isGameOver()) {
            playerMove();
            if (isGameOver()) {
                break;
            }
            computerMove();
            printBoard();
        }

        char winner = getWinner();
        if (winner == player) {
            cout << "Congratulations! You win!" << endl;
        } else if (winner == computer) {
            cout << "Sorry, you lose. Computer wins!" << endl;
        } else {
            cout << "It's a draw!" << endl;
        }
    }

    void playerMove() {
        cout << "Enter your move (1-9): ";
        int move;
        cin >> move;

        int row = (move - 1) / 3;
        int col = (move - 1) % 3;

        if (board[row][col] == '*') {
            board[row][col] = player;
        } else {
            cout << "Invalid move. Please choose an empty cell." << endl;
            playerMove();
        }

        printBoard();
    }

    void computerMove() {
        int bestScore = INT_MIN;
        int bestMoveRow, bestMoveCol;

        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (board[i][j] == '*') {
                    board[i][j] = computer;
                    int score = minimax(board, 0, false);
                    board[i][j] = '*';

                    if (score > bestScore) {
                        bestScore = score;
                        bestMoveRow = i;
                        bestMoveCol = j;
                    }
                }
            }
        }

        board[bestMoveRow][bestMoveCol] = computer;
    }

    int minimax(vector<vector<char>>& board, int depth, bool isMaximizingPlayer) {
        if (isGameOver()) {
            char winner = getWinner();
            if (winner == computer) {
                return 1;
            } else if (winner == player) {
                return -1;
            } else {
                return 0;
            }
        }

        if (isMaximizingPlayer) {
            int bestScore = INT_MIN;

            for (int i = 0; i < 3; i++) {
                for (int j = 0; j < 3; j++) {
                    if (board[i][j] == '*') {
                        board[i][j] = computer;
                        int score = minimax(board, depth + 1, false);
                        board[i][j] = '*';
                        bestScore = max(score, bestScore);
                    }
                }
            }

            return bestScore;
        } else {
            int bestScore = INT_MAX;

            for (int i = 0; i < 3; i++) {
                for (int j = 0; j < 3; j++) {
                    if (board[i][j] == '*') {
                        board[i][j] = player;
                        int score = minimax(board, depth + 1, true);
                        board[i][j] = '*';
                        bestScore = min(score, bestScore);
                    }
                }
            }

            return bestScore;
        }
    }

    bool isGameOver() {
        return isBoardFull() || getWinner() != ' ';
    }

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

    char getWinner() {
        for (int i = 0; i < 3; i++) {
            if (board[i][0] != '*' && board[i][0] == board[i][1] && board[i][0] == board[i][2]) {
                return board[i][0];
            }
        }

        for (int j = 0; j < 3; j++) {
            if (board[0][j] != '*' && board[0][j] == board[1][j] && board[0][j] == board[2][j]) {
                return board[0][j];
            }
        }

        if (board[0][0] != '*' && board[0][0] == board[1][1] && board[0][0] == board[2][2]) {
            return board[0][0];
        }

        if (board[0][2] != '*' && board[0][2] == board[1][1] && board[0][2] == board[2][0]) {
            return board[0][2];
        }

        return ' ';
    }

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

int main() {
    TicTacToe game;
    game.startGame();
    return 0;
}

程序说明

程序使用 TicTacToe 类来封装游戏逻辑。
minimax 函数使用递归实现极小极大算法，计算每个位置的分数，并选择分数最高的位置下棋。
isGameOver 和 getWinner 函数分别用来判断游戏是否结束和获取胜利者。
printBoard 函数用于显示棋盘状态。

运行程序

编译并运行程序后，程序将引导用户选择棋子，并进行游戏。用户需要根据提示输入下棋位置，计算机将根据当前棋盘状态选择最优的下棋位置。

未来改进

可以增加棋盘大小设置的功能，让用户可以自定义棋盘尺寸。
可以改进评分规则，以提高计算机的智能性。
可以考虑使用更先进的搜索算法，例如 Alpha-Beta 剪枝算法，来进一步提高计算机的效率。

总结

本程序提供了一个简单的 3x3 人机对战 Tic Tac Toe 游戏的实现，使用 C++ 类和极小极大算法来实现游戏逻辑和计算机的智能性。用户可以根据需要进一步完善程序功能。

人机对战3x3 Tic Tac Toe 游戏：C++ 类实现