用c++编写康威生命游戏，要求可以回滚上一代模拟状况

好的，我可以为您提供一个简单的实现，使用C++语言和命令行界面，可以回滚上一代模拟状态。

康威生命游戏是一种模拟细胞生命和死亡的经典游戏，规则简单，但产生了复杂的行为。

以下是实现的步骤：

1.定义一个Cell类表示每个细胞的状态。Cell有两个状态：存活和死亡。

class Cell {
public:
    bool isAlive;
    
    Cell() {
        isAlive = false;
    }
};

2.定义一个Board类表示整个生命游戏的棋盘。其中包含一个二维的Cell数组表示整个棋盘。

class Board {
public:
    int size;
    Cell** cells;
    Cell** prev_cells;
    int generation;
    
    Board(int _size) {
        size = _size;
        generation = 0;
        cells = new Cell*[size];
        prev_cells = new Cell*[size];
        for (int i = 0; i < size; i++) {
            cells[i] = new Cell[size];
            prev_cells[i] = new Cell[size];
        }
    }
    
    ~Board() {
        for (int i = 0; i < size; i++) {
            delete[] cells[i];
            delete[] prev_cells[i];
        }
        delete[] cells;
        delete[] prev_cells;
    }
    
    void randomize() {
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                cells[i][j].isAlive = rand() % 2;
            }
        }
    }
    
    void print() {
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                if (cells[i][j].isAlive) {
                    std::cout << "O";
                } else {
                    std::cout << ".";
                }
            }
            std::cout << std::endl;
        }
    }
    
    void nextGeneration() {
        generation++;
        copyCells();
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                int count = countNeighbors(i, j);
                if (prev_cells[i][j].isAlive) {
                    if (count < 2 || count > 3) {
                        cells[i][j].isAlive = false;
                    }
                } else {
                    if (count == 3) {
                        cells[i][j].isAlive = true;
                    }
                }
            }
        }
    }
    
    void copyCells() {
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                prev_cells[i][j].isAlive = cells[i][j].isAlive;
            }
        }
    }
    
    int countNeighbors(int x, int y) {
        int count = 0;
        for (int i = -1; i <= 1; i++) {
            for (int j = -1; j <= 1; j++) {
                if (i == 0 && j == 0) continue;
                int p = x + i;
                int q = y + j;
                if (p >= 0 && p < size && q >= 0 && q < size && prev_cells[p][q].isAlive) {
                    count++;
                }
            }
        }
        return count;
    }
    
    void rollback() {
        generation--;
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                cells[i][j].isAlive = prev_cells[i][j].isAlive;
            }
        }
    }
};

3.在Board类中添加一个rollback函数，该函数将当前棋盘状态回滚到上一代状态。为了保存上一代状态，我们使用一个prev_cells数组，每次更新棋盘时，将当前状态复制到prev_cells中。

4.在main函数中，我们创建一个Board对象，并提供一个命令行界面。用户可以使用命令“next”来模拟下一代，使用命令“rollback”来回滚到上一代，使用命令“exit”来退出游戏。

int main() {
    srand(time(NULL));
    int size = 20;
    Board board(size);
    board.randomize();
    board.print();
    while (true) {
        std::string cmd;
        std::cin >> cmd;
        if (cmd == "next") {
            board.nextGeneration();
            board.print();
        } else if (cmd == "rollback") {
            if (board.generation > 0) {
                board.rollback();
                board.print();
            } else {
                std::cout << "Cannot rollback further" << std::endl;
            }
        } else if (cmd == "exit") {
            break;
        } else {
            std::cout << "Invalid command" << std::endl;
        }
    }
    return 0;
}

这个实现可能不是最优的，但是它提供了一个简单而有趣的康威生命游戏实现，并且可以回滚上一代状态。您可以根据需要进行扩展和改进。