Question

Hello, I am trying to write this program and have received a "Segmentation Fault" error but cannot seem to figure out where. I haven't been able to find it and have been looking for quite a while. The goal is to basically create a version of Conway's Game of Life. I am able to generate a table if the input values for rows and columns are equal, but if they are not I receive a segmentation fault and cannot continue on into the next generation. Please help.

#include <iostream> # include <cstdlib> using namespace std; const char ALIVE = '*'; const char DEAD = ' '; void initialization(bool **world, int nrows, int ncols); //prompts and reads the alive cells to initialize the world void generation(bool **world, bool **copy, int nrows, int ncols); void display(bool **world, int nrows, int ncols); int evolve(bool **world, int nrows, int ncols, int row, int col); //returns the number of alive neighboring cells

int main() { bool **world, **copy int nrows, ncols; char next; cout << "Enter world dimensions (rows and columns): "; cin >> nrows >> ncols; world = new bool*[nrows]; copy = new bool*[nrows]; for(int i=0; i<nrows; i++) { world[i] = new bool[ncols]; copy[i] = new bool[ncols]; } initialization(world, nrows, ncols); display(world, nrows, ncols); } while(true){ cout <, "next Generation or Quit (g/q): "; cin >> next; if(next=='g' || next =='G' || next=='q' || next=='Q') break; } while(next=='g' || next =='G') { generation(world, copy, nrows, ncols); display(world, nrows, ncols); while(true) { cout << "next Generation or Quit (g/q): "; cin >> next; if(next =='g' || next=='G' || next=='q' || next=='Q') break; } } for(int i=0; i<ncols; i++) { delete world[i]; delete copy[i]; } delete world; delete copy; return 0; }

void generation(bool **world, bool **copy, int nrows, int ncols) { int alive_matches; for(int i=0; i<nrows; i++) { for int j=0; j<ncols; j++) copy[i][j] = world[i][j]; } for(int i=0; i<nrows; i++) { for(int j=0; j<ncols; j++) { alive_matches = evolve(copy, nrows, ncols, i, j); if(world[i][j]) { if(alive_matches < 2 || alive_matches > 3) //determines potential death by lonliness or over crowding world[i][j] = false; } else { if(alive_matches == 3) //determines birth of new cell world[i][j] = true; } } } }

void initialization(bool **world, int nrows, int ncols) { int alive, row, col; for(int i=0; i<nrows; i++) { for int j=0; j<ncols; j++) world[i][j] = false; } cout << "Enter the number of initial alive cells: "; cin >> alive; Cout << "Enter the coordinates of alive cells: " << endl; for(int i=0; i<alive;) { cin >> row >> col; if((row >= 0) && (row < nrows) && (col >= 0) && (col < ncols) && (!world[row][col)) { world[row][col] = true; i++; } } }

void display(bool **world, int nrows, int ncols) { for(int i=0; i<nrows; i++) { cout << endl; << "|"; for(int j=0; j<ncols; j++) { if(world[i][j]) cout << ALIVE << "|"; else cout << DEAD << "|"; } cout << endl; << string(ncols*5, '='); } cout << endl; }

int evolve(bool **world, int nrows, int ncols, int row, int col) { int alive_neighbours = 0; if(((row-1) >= 0) && world[row-1][col]) alive_neighbours++; if(((row-1)>=0) && ((col+1) < ncols) && world[row-1][col+1]) alive_neighbours++; if(((col-1)>=0) && world[row][col-1]) alive_neighbours++; if(((col+1)<ncols) && world[row][col+1]) alive_neighbours++; if(((row+1)<nrows) && ((col-1) >= 0) && world[row+1][col-1]) alive_neighbours++; return alive_neighbours; }

Answer 1

I tested the code lot of inputs with rows and columns different. It gives the perfect results. The only problem is, counting the neighbours. You consider only one diagonal neighbour. Take care of alive co-ordinates. You might exceed the memory boundaries while giving the row,col values.

EG:

nrows=4

ncols=2

row=4

col=1

gives segmentation error.

//input:

5
4
6
1
2
1
3
1
1
2
3
2
2
2
0
g
g
g
g
g
q

Enter world dimensions (rows and columns): Enter the number of initial alive cells: Enter the coordinates of alive cells:

| | | | |
====================
| |*|*|*|
====================
|*| |*|*|
====================
| | | | |
====================
| | | | |
====================
next Generation or Quit (g/q):
| | | | |
====================
| |*|*|*|
====================
| | |*|*|
====================
| | | | |
====================
| | | | |
====================
next Generation or Quit (g/q):
| | | | |
====================
| | |*|*|
====================
| |*|*|*|
====================
| | | | |
====================
| | | | |
====================
next Generation or Quit (g/q):
| | | | |
====================
| | |*|*|
====================
| |*| |*|
====================
| | | | |
====================
| | | | |
====================
next Generation or Quit (g/q):
| | | | |
====================
| | |*| |
====================
| | | | |
====================
| | | | |
====================
| | | | |
====================
next Generation or Quit (g/q):
| | | | |
====================
| | | | |
====================
| | | | |
====================
| | | | |
====================
| | | | |
====================
next Generation or Quit (g/q):