complete the code with comments given

The game is called Game of Life:

Any live cell with fewer than two live neighbours dies, as if caused by underpopulation.

Any live cell with two or three live neighbours lives on to the next generation.

Any live cell with more than three live neighbours dies, as if by overpopulation.

Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.

https://en.wikipedia.org/wiki/Conway's_Game_of_Life

#include // Provides ostream

#include // String operations

#include // Randomizer

namespace csci231

{

using std::string;

using std::ostream;

using std::istream;

class Cell

{

friend class GameOfLife;

public:

static const char alive ='o'; // alive image

static const char dead = '-'; // dead image

// Default constructor sets the cell's state to false

Cell();

// Custom constructor sets the cell's state as per argument

Cell(bool state);

// Empty destructor

~Cell();

// Accessors have no intention to modify the object, so it is a good practice to make them 'const' functions

bool getState() const;

// Mutator to change cell's state

void setState(bool newState);

// Accessor to see the 'face'

char getFace() const;

private:

bool state;

char face;

};

class GameOfLife

{

public:

static const unsigned int MAX_BOARD = 30;

GameOfLife();

GameOfLife(size_t boardSize);

~GameOfLife();

int seedBoard(string fileName);

void seedBoard(size_t seeds);

void run();

void run(unsigned int numberOfIterations);

// ADVANCED

// A const(!) accessor method that returns a handle to the private currentLife array.

// The return type must also be 'const' because we return a pointer to a static array, and these are fixed

// It is just an example. It is not needed if we have a friend operator.

const Cell(*getCurrentLife() const )[MAX_BOARD+2] { return currentLife; };

///////////////////////////////////////////////////////

// friend operator can access private members of GameOfLife

friend ostream& operator << (ostream& out, const GameOfLife& board);

friend istream& operator >> (istream& in, const GameOfLife& board);

private:

bool executeRules(unsigned int countAlive, bool currentState);

// With "Halo" approach we need a bigger board

Cell currentLife[MAX_BOARD + 2][MAX_BOARD + 2];

Cell nextLife[MAX_BOARD + 2][MAX_BOARD + 2];

// ADVANCED

// Example how to declare variable cl as a pointer/handle to our array of Cells of size HALO_BOARD

// The accessor method getCurrentLife() above uses the same syntax for the return type

const Cell(*cl)[MAX_BOARD + 2] = currentLife;

////////////////////////////////////////////////////////

size_t boardSize; // Board size requested in the constructor

};

// NON-MEMBER OUTPUT FUNCTIONS

// Display cell's state with alive/dead face

ostream& operator << (ostream& out, const Cell& cell);

}