在c++中采取运算符重载与模板编写五子棋游戏

好的，下面是在C++中采取运算符重载与模板编写五子棋游戏的代码实现。

首先是棋子类的定义，需要记录棋子的颜色和位置信息：

enum class ChessColor { BLACK, WHITE, NONE };

class Chess {
public:
    ChessColor color;
    int x, y;
    Chess(ChessColor _color, int _x, int _y) : color(_color), x(_x), y(_y) {}
};

接下来是棋盘类的定义，使用一个二维数组来表示棋盘，同时定义了一些常量和运算符重载：

const int BOARD_SIZE = 15;

class Board {
public:
    Chess board[BOARD_SIZE][BOARD_SIZE];
    Board() {
        for (int i = 0; i < BOARD_SIZE; i++) {
            for (int j = 0; j < BOARD_SIZE; j++) {
                board[i][j].color = ChessColor::NONE;
                board[i][j].x = i;
                board[i][j].y = j;
            }
        }
    }
    Chess& operator()(int x, int y) { return board[x][y]; }
    const Chess& operator()(int x, int y) const { return board[x][y]; }
    bool operator==(const Board& rhs) const {
        for (int i = 0; i < BOARD_SIZE; i++) {
            for (int j = 0; j < BOARD_SIZE; j++) {
                if (board[i][j].color != rhs.board[i][j].color) {
                    return false;
                }
            }
        }
        return true;
    }
    bool operator!=(const Board& rhs) const { return !(*this == rhs); }
};

接着是游戏类的定义，使用模板类来支持不同类型的玩家：

template <typename Player1, typename Player2>
class Game {
public:
    Board board;
    Player1 player1;
    Player2 player2;
    Game(const Player1& _player1, const Player2& _player2) : player1(_player1), player2(_player2) {}
    void start() {
        int turn = 0;
        ChessColor current_color = ChessColor::BLACK;
        while (true) {
            Board prev_board = board;
            ChessMove move;
            if (current_color == ChessColor::BLACK) {
                move = player1.play(board, current_color);
            } else {
                move = player2.play(board, current_color);
            }
            if (!is_valid_move(move)) {
                std::cerr << "Invalid move, try again!" << std::endl;
                continue;
            }
            board(move.x, move.y).color = current_color;
            if (is_game_over()) {
                std::cout << "Game over!" << std::endl;
                break;
            }
            if (board == prev_board) {
                std::cerr << "No progress made, try again!" << std::endl;
                continue;
            }
            turn++;
            current_color = (turn % 2 == 0) ? ChessColor::BLACK : ChessColor::WHITE;
        }
    }
private:
    bool is_valid_move(const ChessMove& move) const {
        if (move.x < 0 || move.x >= BOARD_SIZE || move.y < 0 || move.y >= BOARD_SIZE) {
            return false;
        }
        if (board(move.x, move.y).color != ChessColor::NONE) {
            return false;
        }
        return true;
    }
    bool is_game_over() const {
        // Check rows
        for (int i = 0; i < BOARD_SIZE; i++) {
            for (int j = 0; j < BOARD_SIZE - 4; j++) {
                if (board(i, j).color != ChessColor::NONE &&
                    board(i, j).color == board(i, j + 1).color &&
                    board(i, j).color == board(i, j + 2).color &&
                    board(i, j).color == board(i, j + 3).color &&
                    board(i, j).color == board(i, j + 4).color) {
                    return true;
                }
            }
        }
        // Check columns
        for (int i = 0; i < BOARD_SIZE - 4; i++) {
            for (int j = 0; j < BOARD_SIZE; j++) {
                if (board(i, j).color != ChessColor::NONE &&
                    board(i, j).color == board(i + 1, j).color &&
                    board(i, j).color == board(i + 2, j).color &&
                    board(i, j).color == board(i + 3, j).color &&
                    board(i, j).color == board(i + 4, j).color) {
                    return true;
                }
            }
        }
        // Check diagonals
        for (int i = 0; i < BOARD_SIZE - 4; i++) {
            for (int j = 0; j < BOARD_SIZE - 4; j++) {
                if (board(i, j).color != ChessColor::NONE &&
                    board(i, j).color == board(i + 1, j + 1).color &&
                    board(i, j).color == board(i + 2, j + 2).color &&
                    board(i, j).color == board(i + 3, j + 3).color &&
                    board(i, j).color == board(i + 4, j + 4).color) {
                    return true;
                }
            }
        }
        for (int i = 0; i < BOARD_SIZE - 4; i++) {
            for (int j = 4; j < BOARD_SIZE; j++) {
                if (board(i, j).color != ChessColor::NONE &&
                    board(i, j).color == board(i + 1, j - 1).color &&
                    board(i, j).color == board(i + 2, j - 2).color &&
                    board(i, j).color == board(i + 3, j - 3).color &&
                    board(i, j).color == board(i + 4, j - 4).color) {
                    return true;
                }
            }
        }
        return false;
    }
};

最后是玩家类的定义，需要实现play方法来返回一个合法的下棋位置：

class HumanPlayer {
public:
    ChessMove play(const Board& board, ChessColor color) {
        while (true) {
            std::cout << "Enter your move (x y): ";
            int x, y;
            std::cin >> x >> y;
            if (std::cin.fail()) {
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
                std::cerr << "Invalid input, try again!" << std::endl;
                continue;
            }
            return ChessMove(x, y);
        }
    }
};

class RandomPlayer {
public:
    ChessMove play(const Board& board, ChessColor color) {
        std::vector<ChessMove> moves;
        for (int i = 0; i < BOARD_SIZE; i++) {
            for (int j = 0; j < BOARD_SIZE; j++) {
                if (board(i, j).color == ChessColor::NONE) {
                    moves.push_back(ChessMove(i, j));
                }
            }
        }
        std::random_device rd;
        std::mt19937 g(rd());
        std::shuffle(moves.begin(), moves.end(), g);
        return moves.front();
    }
};

在main函数中，可以使用如下代码来开始游戏：

int main() {
    Game<HumanPlayer, RandomPlayer> game(HumanPlayer(), RandomPlayer());
    game.start();
    return 0;
}

这样就完成了在C++中采取运算符重载与模板编写五子棋游戏的实现。