康威的生命游戲 - C ++和Qt

Question

我已經完成了所有的布局，並且編寫了大部分代碼。 但是，我被困在兩個地方。

1）我不太確定如何設置計時器。 我在gridwindow類中正確使用它嗎？ 而且，我是否正確使用了定時器功能/信號/插槽與其他網格窗口功能。

2）在GridWindow的timerFired（）函數中，我無法檢查/創建向量向量。 我在該函數的評論中寫到了我正在嘗試的內容。

任何幫助將非常感激。

main.cpp中

// Main file for running the grid window application.
#include <QApplication>
#include "gridwindow.h"
//#include "timerwindow.h"
#include <stdexcept>
#include <string>
#include <fstream>
#include <sstream>
#include <iostream>

void Welcome();             // Welcome Function - Prints upon running program; outputs program name, student name/id, class section.
void Rules();               // Rules Function: Prints the rules for Conway's Game of Life.

using namespace std;

// A simple main method to create the window class  and then pop it up on the screen.
int main(int argc, char *argv[])
{
    Welcome();                                      // Calls Welcome function to print student/assignment info.
    Rules();                                        // Prints Conway's Game Rules.
    QApplication app(argc, argv);                   // Creates the overall windowed application.
    int rows = 25, cols = 35;                       //The number of rows & columns in the game grid.
    GridWindow widget(NULL,rows,cols);              // Creates the actual window (for the grid).
    widget.show();                                  // Shows the window on the screen.
    return app.exec();                              // Goes into visual loop; starts executing GUI.
}    

// Welcome Function: Prints my name/id, my class number, the assignment, and the program name.
void Welcome()                                                              
{
    cout << endl;
    cout << "-------------------------------------------------------------------------------------------------" << endl;
    cout << "Name/ID - Gabe Audick #7681539807" << endl;
    cout << "Class/Assignment - CSCI-102 Disccusion 29915: Homework Assignment #4" << endl;
    cout << "-------------------------------------------------------------------------------------------------" << endl << endl;
}

// Rules Function: Prints the rules for Conway's Game of Life.
void Rules()
{
    cout << "Welcome to Conway's Game of Life." << endl;
    cout << "Game Rules:" << endl;
    cout << "\t 1) Any living cell with fewer than two living neighbours dies, as if caused by underpopulation." << endl;
    cout << "\t 2) Any live cell with more than three live neighbours dies, as if by overcrowding." << endl;
    cout << "\t 3) Any live cell with two or three live neighbours lives on to the next generation." << endl;
    cout << "\t 4) Any dead cell with exactly three live neighbours becomes a live cell." << endl << endl;
    cout << "Enjoy." << endl << endl;
}

gridcell.h

// A header file for a class representing a single cell in a grid of cells.
#ifndef GRIDCELL_H_
#define GRIDCELL_H_

#include <QPalette>
#include <QColor>
#include <QPushButton>
#include <Qt>
#include <QWidget>
#include <QFrame>
#include <QHBoxLayout>
#include <iostream>

// An enum representing the two different states a cell can have. 
enum CellType
{
    DEAD,                   // DEAD = Dead Cell. --> Color = White.
    LIVE                    // LIVE = Living Cell. ---> Color = White.
};

/*
Class: GridCell.
    A class representing a single cell in a grid.  Each cell is implemented
    as a QT QFrame that contains a single QPushButton.  The button is sized
    so that it takes up the entire frame.  Each cell also keeps track of what
    type of cell it is based on the CellType enum.
*/
class GridCell : public QFrame
{
    Q_OBJECT                            // Macro allowing us to have signals & slots on this object.

    private:    
        QPushButton* button;            // The button inside the cell that gives its clickability.
        CellType type;                  // The type of cell (DEAD or LIVE.)

    public slots:
        void handleClick();             // Callback for handling a click on the current cell.
        void setType(CellType type);    // Cell type mutator. Calls the "redrawCell" function.

    signals:
        void typeChanged(CellType type);        // Signal to notify listeners when the cell type has changed.

    public:
        GridCell(QWidget *parent = NULL);       // Constructor for creating a cell. Takes parent widget or default parent to NULL.
        virtual ~GridCell();                    // Destructor.
        void redrawCell();                      // Redraws cell: Sets new type/color.
        CellType getType() const;               //Simple getter for the cell type.

    private:
        Qt::GlobalColor getColorForCellType();  // Helper method. Returns color that cell should be based from its value.       
};

#endif

gridcell.cpp

#include <iostream>

#include "gridcell.h"
#include "utility.h"

using namespace std;

// Constructor: Creates a grid cell.
GridCell::GridCell(QWidget *parent)
: QFrame(parent)
{ 
    this->type = DEAD;              // Default: Cell is DEAD (white).
    setFrameStyle(QFrame::Box);     // Set the frame style.  This is what gives each box its black border.

    this->button = new QPushButton(this);           //Creates button that fills entirety of each grid cell.
    this->button->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);         // Expands button to fill space.
    this->button->setMinimumSize(19,19); //width,height                                 // Min height and width of button.

    QHBoxLayout *layout = new QHBoxLayout();                //Creates a simple layout to hold our button and add the button to it.
    layout->addWidget(this->button);
    setLayout(layout);

    layout->setStretchFactor(this->button,1);       // Lets the buttons expand all the way to the edges of the current frame with no space leftover
    layout->setContentsMargins(0,0,0,0);
    layout->setSpacing(0);

    connect(this->button,SIGNAL(clicked()),this,SLOT(handleClick()));   // Connects clicked signal with handleClick slot.
    redrawCell();           // Calls function to redraw (set new type for) the cell.
}

// Basic destructor. 
GridCell::~GridCell()
{
    delete this->button;
}


// Accessor for the cell type.
CellType GridCell::getType() const
{
    return(this->type);
}

// Mutator for the cell type.  Also has the side effect of causing the cell to be redrawn on the GUI.
void GridCell::setType(CellType type)
{
    this->type = type;
    redrawCell();
}

// Handler slot for button clicks.  This method is called whenever the user clicks on this cell in the grid.
void GridCell::handleClick()
{                                   // When clicked on...
  if(this->type == DEAD)            // If type is DEAD (white), change to LIVE (black).
    type = LIVE;
  else 
    type = DEAD;                    // If type is LIVE (black), change to DEAD (white).

  setType(type);                    // Sets new type (color). setType Calls redrawCell() to recolor.
}

// Method to check cell type and return the color of that type.  
Qt::GlobalColor GridCell::getColorForCellType()
{
    switch(this->type)
    {
        default:
        case DEAD:
            return Qt::white;
        case LIVE:
            return Qt::black;
    }
}


// Helper method. Forces current cell to be redrawn on the GUI.  Called whenever the setType method is invoked.
void GridCell::redrawCell()
{
    Qt::GlobalColor gc = getColorForCellType();         //Find out what color this cell should be.
    this->button->setPalette(QPalette(gc,gc));          //Force the button in the cell to be the proper color.
    this->button->setAutoFillBackground(true);
    this->button->setFlat(true);                        //Force QT to NOT draw the borders on the button
}

gridwindow.h

// A header file for a QT window that holds a grid of cells.
#ifndef GRIDWINDOW_H_
#define GRIDWINDOW_H_

#include <vector>
#include <QWidget>
#include <QTimer>
#include <QGridLayout>
#include <QLabel>
#include <QApplication>
#include "gridcell.h"

/*
class GridWindow:
    This is the class representing the whole window that comes up when this program runs.  
    It contains a header section with a title, a middle section of MxN cells and a bottom section with buttons.
*/
class GridWindow : public QWidget
{
    Q_OBJECT                            // Macro to allow this object to have signals & slots.

    private:
        std::vector<std::vector<GridCell*> > cells;     // A 2D vector containing pointers to all the cells in the grid.
        QLabel *title;                                  // A pointer to the Title text on the window.
        QTimer *timer;                                  // Creates timer object.

    public slots:
        void handleClear();             // Handler function for clicking the Clear button.
        void handleStart();             // Handler function for clicking the Start button.
        void handlePause();             // Handler function for clicking the Pause button.
        void timerFired();              // Method called whenever timer fires.

    public:
        GridWindow(QWidget *parent = NULL,int rows=3,int cols=3);       // Constructor.
        virtual ~GridWindow();                                          // Destructor.
        std::vector<std::vector<GridCell*> >& getCells();               // Accessor for the array of grid cells.

    private:
        QHBoxLayout* setupHeader();                     // Helper function to construct the GUI header.
        QGridLayout* setupGrid(int rows,int cols);      // Helper function to constructor the GUI's grid.
        QHBoxLayout* setupButtonRow();                  // Helper function to setup the row of buttons at the bottom.
};

#endif

gridwindow.cpp

#include <iostream>
#include "gridwindow.h"

using namespace std;

// Constructor for window. It constructs the three portions of the GUI and lays them out vertically.
GridWindow::GridWindow(QWidget *parent,int rows,int cols)
: QWidget(parent)
{
    QHBoxLayout *header = setupHeader();            // Setup the title at the top.
    QGridLayout *grid = setupGrid(rows,cols);       // Setup the grid of colored cells in the middle.
    QHBoxLayout *buttonRow = setupButtonRow();      // Setup the row of buttons across the bottom.
    QVBoxLayout *layout = new QVBoxLayout();        // Puts everything together.
    layout->addLayout(header);
    layout->addLayout(grid);
    layout->addLayout(buttonRow);
    setLayout(layout);
}

// Destructor.
GridWindow::~GridWindow()
{
    delete title;
}

// Builds header section of the GUI.  
QHBoxLayout* GridWindow::setupHeader()
{
    QHBoxLayout *header = new QHBoxLayout();            // Creates horizontal box.
    header->setAlignment(Qt::AlignHCenter);

    this->title = new QLabel("CONWAY'S GAME OF LIFE",this);             // Creates big, bold, centered label (title): "Conway's Game of Life."
    this->title->setAlignment(Qt::AlignHCenter);
    this->title->setFont(QFont("Arial", 32, QFont::Bold));

    header->addWidget(this->title);     // Adds widget to layout.

    return header;                      // Returns header to grid window.
}

// Builds the grid of cells.  This method populates the grid's 2D array of GridCells with MxN cells.
QGridLayout* GridWindow::setupGrid(int rows,int cols)
{
    QGridLayout *grid = new QGridLayout();      // Creates grid layout.

    grid->setHorizontalSpacing(0);              // No empty spaces. Cells should be contiguous.
    grid->setVerticalSpacing(0);
    grid->setSpacing(0);
    grid->setAlignment(Qt::AlignHCenter);

    for(int i=0; i < rows; i++)                     //Each row is a vector of grid cells.
    {
        std::vector<GridCell*> row;                 // Creates new vector for current row.
        cells.push_back(row);
        for(int j=0; j < cols; j++)
        {
            GridCell *cell = new GridCell();        // Creates and adds new cell to row.
            cells.at(i).push_back(cell);

            grid->addWidget(cell,i,j);              // Adds to cell to grid layout. Column expands vertically.
            grid->setColumnStretch(j,1);
        }
        grid->setRowStretch(i,1);                   // Sets row expansion horizontally.
    }
    return grid;                                    // Returns grid.
}

// Builds footer section of the GUI.  
QHBoxLayout* GridWindow::setupButtonRow()
{
    QHBoxLayout *buttonRow = new QHBoxLayout();     // Creates horizontal box for buttons.
    buttonRow->setAlignment(Qt::AlignHCenter);

    // Clear Button - Clears cell; sets them all to DEAD/white.
    QPushButton *clearButton = new QPushButton("CLEAR");
    clearButton->setFixedSize(100,25); 
    connect(clearButton, SIGNAL(clicked()), this, SLOT(handleClear()));     
    buttonRow->addWidget(clearButton);

    // Start Button - Starts game when user clicks. Or, resumes game after being paused.
    QPushButton *startButton = new QPushButton("START/RESUME");
    startButton->setFixedSize(100,25);              
    connect(startButton, SIGNAL(clicked()), this, SLOT(handleStart()));     
    buttonRow->addWidget(startButton);

    // Pause Button - Pauses simulation of game.
    QPushButton *pauseButton = new QPushButton("PAUSE");
    pauseButton->setFixedSize(100,25);              
    connect(pauseButton, SIGNAL(clicked()), this, SLOT(handlePause()));     
    buttonRow->addWidget(pauseButton);  

    // Quit Button - Exits program.
    QPushButton *quitButton = new QPushButton("EXIT");
    quitButton->setFixedSize(100,25); 
    connect(quitButton, SIGNAL(clicked()), qApp, SLOT(quit()));     
    buttonRow->addWidget(quitButton);

    return buttonRow;               // Returns bottom of layout.
}

/*
    SLOT method for handling clicks on the "clear" button. 
    Receives "clicked" signals on the "Clear" button and sets all cells to DEAD.
*/
void GridWindow::handleClear()
{
    for(unsigned int row=0; row < cells.size(); row++)          // Loops through current rows' cells.
    {
    for(unsigned int col=0; col < cells[row].size(); col++)
        {
            GridCell *cell = cells[row][col];                   // Grab the current cell & set its value to dead.
            cell->setType(DEAD);
        }
    }
}

/*
    SLOT method for handling clicks on the "start" button. 
    Receives "clicked" signals on the "start" button and begins game simulation.
*/
void GridWindow::handleStart()
{
    this->timer = new QTimer(this);                                     // Creates new timer.
    connect(this->timer, SIGNAL(timeout()), this, SLOT(timerFired()));  // Connect "timerFired" method class to the "timeout" signal fired by the timer.
    this->timer->start(500);                                            // Timer to fire every 500 milliseconds.
}

/*
    SLOT method for handling clicks on the "pause" button. 
    Receives "clicked" signals on the "pause" button and stops the game simulation.
*/
void GridWindow::handlePause()
{
        this->timer->stop();        // Stops the timer.
        delete this->timer;         // Deletes timer.
}

// Accessor method - Gets the 2D vector of grid cells.
std::vector<std::vector<GridCell*> >& GridWindow::getCells()
{
    return this->cells;
}


void GridWindow::timerFired()
{
    // I'm not sure how to write this code.
    // I want to take the original vector-vector, and also make a new, empty vector-vector of the same size.
    // I would then go through the code below with the original vector, and apply the rules to the new vector-vector.
    // Finally, I would make the new vector-vecotr the original vector-vector. (That would be one step in the simulation.)

    cout << cells[1][2];    
    /*
     for (unsigned int m = 0; m < original.size(); m++)
     {
         for (unsigned int n = 0; n < original.at(m).size(); n++)
         {
             unsigned int neighbors = 0;                                //Begin counting number of neighbors.

             if (original[m-1][n-1].getType() == LIVE)      // If a cell next to [i][j] is LIVE, add one to the neighbor count.
                neighbors += 1;
             if (original[m-1][n].getType() == LIVE) 
                neighbors += 1;
             if (original[m-1][n+1].getType() == LIVE) 
                neighbors += 1;
             if (original[m][n-1].getType() == LIVE) 
                neighbors += 1;
             if (original[m][n+1].getType() == LIVE) 
                neighbors += 1;
             if (original[m+1][n-1].getType() == LIVE) 
                neighbors += 1;
             if (original[m+1][n].getType() == LIVE) 
                neighbors += 1;
             if (original[m+1][n+1].getType() == LIVE) 
                neighbors += 1;

             if (original[m][n].getType() == LIVE && neighbors < 2)             // Apply game rules to cells: Create new, updated grid with the roundtwo vector.
                roundtwo[m][n].setType(LIVE);
             else if (original[m][n].getType() == LIVE && neighbors > 3)
                roundtwo[m][n].setType(DEAD);
             else if (original[m][n].getType() == LIVE && (neighbors == 2 || neighbors == 3))
                roundtwo[m][n].setType(LIVE);
             else if (original[m][n].getType() == DEAD && neighbors == 3)
                roundtwo[m][n].setType(LIVE);  
         }
    }*/
}

Answer 1

看起來計時器已正確設置給我。

對於timerFired()函數，我不會創建GridCell對象的臨時矩陣，而只是一個臨時的標志矩陣，用於指示單元格是否存在。 這些標志實際上是函數中的所有變化，因此只需臨時存儲新標志，然后將它們設置在原始網格單元格上，以節省創建臨時單元格矩陣所需的所有額外內存和分配時間。 這是一個例子：

//Store flags that represent whether the new grid cells will be live or not
vector< vector<bool> > is_live(cells.size());
for(int m=0; m<cells.size(); m++)
{
    is_live.at(m).resize(cells.at(m).size());
    for(int n=0; n<cells.at(m).size(); n++)
    {
        //count neighbors
        unsigned int neighbors = 0;
        for(int i=-1; i<=1; i++)
        {
            for(int j=-1; j<=1; j++)
            {
                neighbors += static_cast<int>(
                             cells[m+i][n+j]->getType() == LIVE);
            }
        }
        //we counted the current cell when counting the neighbors so
        //subtract it back off if needed.
        neighbors -= static_cast<int>(cells[m][n]->getType() == LIVE);

        //Set the type to the original value
        is_live[m][n] = cells[m][n]->getType() == LIVE;

        //change it based on the neighbor count.
        //Some of your logic around here seemed repetitive so I 
        //did it differently.  You may want to change it back 
        //if you had a specific purpose for the way you did it
        is_live[m][n] = (is_live[m][n] && neighbors <= 3) || 
                        (!is_live[m][n] && neighbors == 3);
    }
}

//Set the cell types based on the is_live flags.
for(int m=0; m<cells.size(); m++)
{
    for(int n=0; n<cells.at(m).size(); n++)
        cells[m][n]->setType(is_live[m][n] ? LIVE : DEAD);
}

注意：我沒有編譯或測試這個，所以沒有保證。