Is My C++ CellStatus Function Causing Print Failures After First Generation?

  • Context: Comp Sci 
  • Thread starter Thread starter magnifik
  • Start date Start date
  • Tags Tags
    C++ File Printing
Click For Summary

Discussion Overview

The discussion revolves around a C++ function, cellStatus, which is suspected to cause print failures after the first generation in a program. Participants explore potential issues related to the implementation of this function within the printCell function, focusing on input/output stream handling, array manipulations, and neighbor counting logic. The scope includes technical explanations and debugging of code related to cellular automata.

Discussion Character

  • Technical explanation
  • Debugging
  • Exploratory reasoning

Main Points Raised

  • One participant notes that the input and output streams (inf and outf) are not being utilized in the functions, which could lead to issues with printing the new life state.
  • Another participant suggests that the logic in the printCell function may be incorrect, as it appears to overwrite the new life array with the old life array instead of the other way around.
  • Concerns are raised about the initial configuration being read only once, implying that subsequent generations may not have the necessary data to print correctly.
  • Participants discuss the need for clearer comments in the code to understand the purpose of functions better.
  • There is a question about potential errors when counting neighbors for cells at the edges of the grid, with suggestions for handling corner cases.
  • A participant shares code from a previous project to illustrate how to count adjacent cells, which may inform the current problem.
  • Another participant expresses confusion about an asterisk appearing in the output where there should not be one, seeking help to identify the mistake in their neighbor counting logic.

Areas of Agreement / Disagreement

Participants express various viewpoints on the issues with the code, but there is no consensus on the exact cause of the print failures or the best approach to resolve them. Multiple competing views on how to handle edge cases and neighbor counting remain unresolved.

Contextual Notes

There are limitations regarding the assumptions made about the input data and the handling of edge cases in the grid. The discussion highlights the complexity of managing state transitions in cellular automata and the need for careful consideration of array boundaries.

magnifik
Messages
350
Reaction score
0
it prints fine for the first generation, but nothing else after that. i am thinking that my problem lies in the cellStatus function and its implementation within the printCell function. attached are the files that i am getting input from and the file that i am printing to.

Code: 
#include <iostream>
using namespace std;

int main(){
     cout << "Resolved." << endl;
     cout << "Thanks for the help!" << endl;
}
 
Last edited:
Physics news on Phys.org
you are not using inf and outf in either of your functions; if newLife is suppose to be printed to the file you aren't send it
 
Last edited:
RandyPhantom said:
you are not using inf and outf in either of your functions

changing the inStream to inf & outStream to outf doesn't change anything when i execute it
 
RandyPhantom said:
you are not using inf and outf in either of your functions; if newLife is suppose to be printed to the file you aren't send it

my question is how to do so
 
outStream << NewLife[row][col] is missing; i only pointed out the inf and outf because it would cause your teacher to question why pass if you aren't using it and mark off because of it
 
hmm, that didn't work. i assigned newLife[row][col] to be life[row][col] in order to print it, but there's still something wrong
 
It looks to me like this code is backwards:
Code: 
 // overwrite the old life to the new life
 for (int row = 0; row < rowSize; row++)
{
    for (int col = 0; col < colSize; col++)
   {
      newLife[row][col] = life[row][col];
   }
}
This is in your printCell function. The code before it calculated values for your newLife array; now you are overwriting the values. Seems to me you would want to store the new calculated values (newLife) into the life array, not the other way around as you are doing above.
 
Mark44 said:
It looks to me like this code is backwards:
Code: 
 // overwrite the old life to the new life
 for (int row = 0; row < rowSize; row++)
{
    for (int col = 0; col < colSize; col++)
   {
      newLife[row][col] = life[row][col];
   }
}
This is in your printCell function. The code before it calculated values for your newLife array; now you are overwriting the values. Seems to me you would want to store the new calculated values (newLife) into the life array, not the other way around as you are doing above.

i changed that, too, but i still have the same problem.
 
could the problem be the beginning of my printCell function? since the series of 0's and 1's only determines the first generation, this might affect the printGame function. I'm calling the printCell for every generation, but after generation 0, there are no more 0's and 1's to read in.
 
  • #10
That makes sense. You don't have enough comments for me to easily figure out the purpose of this function, but you shouldn't be passing an input stream to it. You have already read in the initial configuration, in printGame. Once the initial configuration is read in, you have no further use for it.

It seems that printCell (which is supposed to print a particular generation, I think - you should make that clear in a comment) should have two parameters: an output stream and a whatever matrix you want to print to the output file.
 
  • #11
Mark44 said:
That makes sense. You don't have enough comments for me to easily figure out the purpose of this function, but you shouldn't be passing an input stream to it. You have already read in the initial configuration, in printGame. Once the initial configuration is read in, you have no further use for it.

It seems that printCell (which is supposed to print a particular generation, I think - you should make that clear in a comment) should have two parameters: an output stream and a whatever matrix you want to print to the output file.

i figured it out! thanks!
 
  • #12
Cool! What did you do to fix things?
 
  • #13
i added the 2D array parameter to the function and created a separate function for the loop that actually prints the asterisks and spaces
 
  • #14
i just thought of another question.. when counting the neighbors, will the program run into an error when it is checking for the neighbors surrounding the cells in row 0 or column 0?
 
  • #15
magnifik said:
i just thought of another question.. when counting the neighbors, will the program run into an error when it is checking for the neighbors surrounding the cells in row 0 or column 0?

yeah. Here is some code from a "count the mines around each cell" program I had to write a while ago. In the program, I had a row by column character double array with '.' representing an empty cell and with '*' representing a mine. Here is the code I wrote to tally up how many adjacent mines each cell had.

Code: 
	for(row = 0; row < rows; ++row)
		for(column = 0; column < columns; ++column)
		{
			if(board[row][column] == '.')
			{
				adjacentMines = 0;
				for(right = -1; right < 2; ++right)
					for(up = -1; up < 2; ++up)
						if(right || up)
							if(row + right > -1 && column + up > -1)
								if(board[row + right][column + up] == '*')
									++adjacentMines;
				if(adjacentMines)
					board[row][column] = adjacentMines + 48;
			}
		}
 
  • #16
so to fix my code i just need to add more for loops restricting the columns and rows in the -1 index?
 
  • #17
I wouldn't do that, but I would treat as special cases
When a cell is at one of the corners.
When a cell is in the first or last row.
When a cell is in the first or last column.

Cells in the corners have only three neighbors. Cells in the first or last row (that aren't corner cells) have only five neighbors. Same for cells in the first or last column that aren't in the corners.

All other cells have eight neighbors.

You don't need another for loop (or similar control structure) to deal with this - you can take care of it with an if ... else if ... else structure.
 
  • #18
i am trying to fix my code, but for some reason there is an asterisk even where there is no occupied cell. can someone catch my mistake, please?

Code: 
/* [row-1][col-1]	        [row-1][col]	[row-1][col+1]
    [row][col-1]	        [row][col]	        [row][col+1]
    [row+1][col-1]  	[row+1][col]	[row+1][col+1] */

if (row == 0){
	if (cell[row][col+1] == 1) neighbors++;
	if (cell[row][col-1] == 1) neighbors++;
	if (cell[row+1][col+1] == 1) neighbors++;
	if (cell[row+1][col] == 1) neighbors++;
	if (cell[row+1][col-1] == 1) neighbors++;
}
else if (row == 0 && col == 0){
	if (cell[row][col+1] == 1) neighbors++;
	if (cell[row+1][col] == 1) neighbors++;
	if (cell[row+1][col+1] == 1) neighbors++;
}
else if (row == 0 && col == colSize){
	if (cell[row][col-1] == 1) neighbors++;
	if (cell[row+1][col] == 1) neighbors++;
	if (cell[row+1][col-1] == 1) neighbors++;
}
else if (row == rowSize && col == 0){
	if (cell[row-1][col] == 1) neighbors++;
	if (cell[row-1][col+1] == 1) neighbors++;
	if (cell[row][col+1] == 1) neighbors++;
}
else if (row == rowSize && col == colSize){
	if (cell[row][col-1] == 1) neighbors++;
	if (cell[row-1][col] == 1) neighbors++;
	if (cell[row-1][col-1] == 1) neighbors++;
}
else if (row == rowSize){
	if (cell[row][col+1] == 1) neighbors++;
	if (cell[row][col-1] == 1) neighbors++;
	if (cell[row-1][col+1] == 1) neighbors++;
	if (cell[row-1][col] == 1) neighbors++;
	if (cell[row-1][col-1] == 1) neighbors++;
}
else if (col == 0){
	if (cell[row][col+1] == 1) neighbors++;
	if (cell[row-1][col] == 1) neighbors++;
	if (cell[row-1][col+1] == 1) neighbors++;
	if (cell[row+1][col] == 1) neighbors++;
	if (cell[row+1][col+1] == 1) neighbors++;
}
else if (col == colSize){
	if (cell[row][col-1] == 1) neighbors++;
	if (cell[row-1][col] == 1) neighbors++;
	if (cell[row-1][col-1] == 1) neighbors++;
	if (cell[row+1][col] == 1) neighbors++;
	if (cell[row+1][col-1] == 1) neighbors++;
}
else{
	if (cell[row-1][col-1] == 1) neighbors++;
	if (cell[row-1][col] == 1) neighbors++;
	if (cell[row-1][col+1] == 1) neighbors++;
	if (cell[row][col-1] == 1) neighbors++;
	if (cell[row][col+1] == 1) neighbors++;
	if (cell[row+1][col-1] == 1) neighbors++;
	if (cell[row+1][col] == 1) neighbors++;
	if (cell[row+1][col+1] == 1) neighbors++;
}
 
Last edited:
  • #19
There are a number of mistakes in this code. Here are the first couple of if clauses.
Code: 
if (row == 0){
	if (cell[row][col+1] == 1) neighbors++;
	if (cell[row][col-1] == 1) neighbors++;
	if (cell[row+1][col+1] == 1) neighbors++;
	if (cell[row+1][col] == 1) neighbors++;
	if (cell[row+1][col-1] == 1) neighbors++;
}
else if (row == 0 && col == 0){
	if (cell[row][col+1] == 1) neighbors++;
	if (cell[row+1][col] == 1) neighbors++;
	if (cell[row+1][col+1] == 1) neighbors++;
}
What happens when row=0 and col=0? The first if clause attempts to check all five neighbors, including the one at cell[0][-1], which is not in your cell array.

When you're checking row 0, you need to first determine whether you are at either endpoint of the row. The same is true for the last row.

When you are checking col 0 or the last column, you need to determine whether you are at either endpoint of the column.

Another possible problem is in this code:
Code: 
else if (row == rowSize && col == colSize){
	if (cell[row][col-1] == 1) neighbors++;
	if (cell[row-1][col] == 1) neighbors++;
	if (cell[row-1][col-1] == 1) neighbors++;
}
Assuming your array has rowSize rows and colSize columns, the rows are numbered 0, 1, 2, ..., rowSize - 1. The columns are numbered 0, 1, 2, ..., colSize - 1. The code above is checking outside the bounds of the array.

You should be able to catch most of these things on your own. One technique is to hand-simulate what your program should do using a small array (say 6 x 6) and a simple initial cell pattern. Run your algorithm a few iterations by hand, to see what should be happening in your program.

Another thing is that you should be using the debugger that is probably available to you, by single-stepping through your code. Doing that would have caught the situation where you're attempting to read outside the bounds of your array.
 
  • #20
woops, i probably should have mentioned that i changed the for loop in this part. here is my modified code + for loop. I'm still unsure on what I'm making mistakes on

Code: 
	 for (int row = 0; row < rowSize; row++){
		 for (int col = 0; col < colSize; col++){
			 // calculate the amount of neighbors each cell has
			 int neighbors = 0;
			 if (col > 0 && col < colSize - 1 && row > 0 && row < rowSize - 1){
				if (cell[row-1][col-1] == 1) neighbors++;
				if (cell[row-1][col] == 1) neighbors++;
				if (cell[row-1][col+1] == 1) neighbors++;
				if (cell[row][col-1] == 1) neighbors++;
				if (cell[row][col+1] == 1) neighbors++;
				if (cell[row+1][col-1] == 1) neighbors++;
				if (cell[row+1][col] == 1) neighbors++;
				if (cell[row+1][col+1] == 1) neighbors++;
			 }
			 else{
			 if (col == 0){
				if (cell[row+1][col] == 1) neighbors++;
				if (cell[row+1][col+1] == 1) neighbors++;
				if (cell[row][col+1] == 1) neighbors++;
				if (cell[row-1][col+1] == 1) neighbors++;
				if (cell[row-1][col] == 1) neighbors++;
			 }
			 if (row == 0 && col == 0){
				 if (cell[row][col+1] == 1) neighbors++;
				 if (cell[row+1][col] == 1) neighbors++;
				 if (cell[row+1][col+1] == 1) neighbors++;
			 }
			 if ((row == rowSize - 1) && col == 0){
				if (cell[row-1][col] == 1) neighbors++;
				if (cell[row-1][col+1] == 1) neighbors++;
				if (cell[row][col+1] == 1) neighbors++;
			 }
			 if (row == 0){
				if (cell[row][col+1] == 1) neighbors++;
				if (cell[row][col-1] == 1) neighbors++;
				if (cell[row+1][col+1] == 1) neighbors++;
				if (cell[row+1][col] == 1) neighbors++;
				if (cell[row+1][col-1] == 1) neighbors++;
			 }
			 if (row == 0 && (col == colSize - 1)){
 				if (cell[row][col-1] == 1) neighbors++;
 				if (cell[row+1][col] == 1) neighbors++;
 				if (cell[row+1][col-1] == 1) neighbors++;
 			 }
			 if (col == colSize - 1){
				if (cell[row][col-1] == 1) neighbors++;
				if (cell[row-1][col] == 1) neighbors++;
				if (cell[row-1][col-1] == 1) neighbors++;
				if (cell[row+1][col] == 1) neighbors++;
				if (cell[row+1][col-1] == 1) neighbors++;
			 }
			 if ((row == rowSize - 1) && (col == colSize - 1)){
				if (cell[row][col-1] == 1) neighbors++;
				if (cell[row-1][col] == 1) neighbors++;
				if (cell[row-1][col-1] == 1) neighbors++;
			 }
			 if (row == rowSize - 1){
				if (cell[row][col+1] == 1) neighbors++;
				if (cell[row][col-1] == 1) neighbors++;
				if (cell[row-1][col+1] == 1) neighbors++;
				if (cell[row-1][col] == 1) neighbors++;
				if (cell[row-1][col-1] == 1) neighbors++;
			 }
			 }
 
Last edited:
  • #21
All or most of the if clauses need to be restructured, since you are processing many of the array cells more than once. Here's an example of what I'm talking about.
Code: 
if (row == 0){
   if (cell[row][col+1] == 1) neighbors++;
   if (cell[row][col-1] == 1) neighbors++;
   if (cell[row+1][col+1] == 1) neighbors++;
   if (cell[row+1][col] == 1) neighbors++;
   if (cell[row+1][col-1] == 1) neighbors++;
}
if (row == 0 && (col == colSize - 1)){
   if (cell[row][col-1] == 1) neighbors++;
   if (cell[row+1][col] == 1) neighbors++;
   if (cell[row+1][col-1] == 1) neighbors++;
}
Suppose you are working with cell[0][colSize-1]. Here row == 0, so the first outer if clause above is entered, and the code checks all 5 neighbors (there are only 3, so that's an error).
Next, since row == 0 and col == colSize -1, the next outer if clause is entered, and the code checks all three neighbors. The thing is, your code has processed cell[0][colSize-1] twice.

The code I picked out is not the only place this is happening. To prevent this from happening, you should reorganize the entire body of the inner for loop. The way I would probably go is like this:
Code: 
Is the cell in the top row of the array?
   Is the cell a corner point? If so, count the 3 neighbors. Otherwise, count the 5 neighbors.
Otherwise, is the cell in the bottom row of the array?
   Is the cell a corner point? If so, count the 3 neighbors. Otherwise, count the 5 neighbors.
Otherwise, is the cell along the left edge of the array? (It isn't a corner, 
      since these have already been processed, above.) If so, count the 5 neighbors.
Otherwise, is the cell along the left edge of the array? (It isn't a corner, 
      since these have already been processed, above.) If so, count the 5 neighbors.
Otherwise, the cell must be in the interior of the array, so count the 8 neighbors.

Also, it doesn't seem to me that you are using your neighbors count correctly. For each cell, the number of neighbors determines the status of that cell in the next iteration of the array (the next life). When you find out how many neighbors a given array cell has, you should be doing something with the next array iteration, and I don't see that happening.
 
  • #22
Wait, what's wrong with letting the computer do all the checks in a compact format? The first two loops work to cycle through all cells to check. The next two for loops cycle through all neighbors for said cell. They take it through all 8 blocks around that said cell as well as through the cell in question. The first if statement makes sure you don't count the cell whose neighbors you're evaluating as a neighbor (if right || up means right and up cannot equal 0 at the same time. If they do, you're on the cell whose neighbors you are evaluating.) The next if statement ensures you do not try to evaluate an illegal index of the array. It cannot be negative in terms of row && it cannot be negative in terms of column && you cannot evaluate a column greater than the biggest column && you cannot evaluate a row greater than the biggest row. The last if statement checks if the neighbor you are evaluating is living.

Another, possibly easier, way to implement your game is to have an n+2 by n+2 board for any game sized at n by n. If you then use the interior parts of the array, with the edges preset to be "dead", you could eliminate all conditional statements since the corner evaluations would occur without causing a run-time error and will always return "dead," meaning it won't affect your game.

Code: 
for(int row = 0; row < rows; ++row)
{
	for(int column = 0; column < columns; ++columns)
	{
                neighbors = 0;
		for(int up = -1; up < 2; ++up)
		{
			for(int right = -1; right < 2; ++right)
			{
				if(right || up)
				{
					if(row + right > -1 && column + up > -1 && column + up < columns && row + right < rows)
					{
						if (cell[row + right][colomn + up] == 1) neighbors++;
					}
				}
			}
		}
	}
}
 
Last edited:
  • #23
xcvxcvvc said:
Wait, what's wrong with letting the computer do all the checks in a compact format?
Being understandable is more important than having a compact format. Right now magnifik is having difficulty understanding what his own code is doing and how that relates to the problem he's trying to solve, so it's probably a little soon for clever solutions. IMO.
 
  • #24
Mark44 said:
Being understandable is more important than having a compact format. Right now magnifik is having difficulty understanding what his own code is doing and how that relates to the problem he's trying to solve, so it's probably a little soon for clever solutions. IMO.

I'm having trouble implementing your solution as well, because you have to think about so much damn stuff.
 
  • #25
Mark44 said:
Also, it doesn't seem to me that you are using your neighbors count correctly. For each cell, the number of neighbors determines the status of that cell in the next iteration of the array (the next life). When you find out how many neighbors a given array cell has, you should be doing something with the next array iteration, and I don't see that happening.

i didn't put that in the segment i put up, but it is in my actual code. thank you for all your help! is what i have below finally right??

Code: 
	 for (int row = 0; row < rowSize; row++){
		 for (int col = 0; col < colSize; col++){
			 // calculate the amount of neighbors each cell has
			 int neighbors = 0;
			 if (row == 0){
				 if (col == 0){
					 if (cell[row][col+1] == 1) neighbors++;
					 if (cell[row+1][col] == 1) neighbors++;
					 if (cell[row+1][col+1] == 1) neighbors++;
				 }
				 if (col == colSize - 1){
					 if (cell[row][col-1] == 1) neighbors++;
					 if (cell[row+1][col] == 1) neighbors++;
					 if (cell[row+1][col-1] == 1) neighbors++;
				 }
				 else{
					 if (cell[row][col+1] == 1) neighbors++;
					 if (cell[row][col-1] == 1) neighbors++;
					 if (cell[row+1][col+1] == 1) neighbors++;
					 if (cell[row+1][col] == 1) neighbors++;
					 if (cell[row+1][col-1] == 1) neighbors++;
				 }
			 }
			 else if (row == rowSize - 1){
				 if (col == 0){
					 if (cell[row-1][col] == 1) neighbors++;
					 if (cell[row-1][col+1] == 1) neighbors++;
					 if (cell[row][col+1] == 1) neighbors++;
				 }
				 if (col == colSize - 1){
					 if (cell[row][col-1] == 1) neighbors++;
					 if (cell[row-1][col] == 1) neighbors++;
					 if (cell[row-1][col-1] == 1) neighbors++;
				 }
				 else{
					 if (cell[row][col+1] == 1) neighbors++;
					 if (cell[row][col-1] == 1) neighbors++;
					 if (cell[row-1][col+1] == 1) neighbors++;
					 if (cell[row-1][col] == 1) neighbors++;
					 if (cell[row-1][col-1] == 1) neighbors++;
				 }
			 }
			 else if (col == 0){
				 if (cell[row+1][col] == 1) neighbors++;
				 if (cell[row+1][col+1] == 1) neighbors++;
				 if (cell[row][col+1] == 1) neighbors++;
				 if (cell[row-1][col+1] == 1) neighbors++;
				 if (cell[row-1][col] == 1) neighbors++;
			 }
			 else if (col == colSize - 1){
				 if (cell[row][col-1] == 1) neighbors++;
				 if (cell[row-1][col] == 1) neighbors++;
				 if (cell[row-1][col-1] == 1) neighbors++;
				 if (cell[row+1][col] == 1) neighbors++;
				 if (cell[row+1][col-1] == 1) neighbors++;
			 }
			 else{
				if (cell[row-1][col-1] == 1) neighbors++;
				if (cell[row-1][col] == 1) neighbors++;
				if (cell[row-1][col+1] == 1) neighbors++;
				if (cell[row][col-1] == 1) neighbors++;
				if (cell[row][col+1] == 1) neighbors++;
				if (cell[row+1][col-1] == 1) neighbors++;
				if (cell[row+1][col] == 1) neighbors++;
				if (cell[row+1][col+1] == 1) neighbors++;
				}
			 // apply the rules of the game, determining births and deaths
             if (cell[row][col] == 1 && neighbors < 2)
                newLife[row][col] = 0;
             else if (cell[row][col] == 1 && neighbors > 3)
                newLife[row][col] = 0;
             else if (cell[row][col] == 1 && (neighbors == 2 || neighbors == 3))
                newLife[row][col] = 1;
             else if (cell[row][col] == 0 && neighbors == 3)
                newLife[row][col] = 1;
		 }
	 }
 
  • #26
I laid out my algorithm in post 21. I'm not saying this is the only or best way to do things, but this is based the approach that magnifik was already taking, but organized so that it wouldn't count an array element twice.
 
  • #27
magnifik said:
i didn't put that in the segment i put up, but it is in my actual code. thank you for all your help! is what i have below finally right??

Code: 
	 for (int row = 0; row < rowSize; row++){
		 for (int col = 0; col < colSize; col++){
			 // calculate the amount of neighbors each cell has
			 int neighbors = 0;
			 if (row == 0){
				 if (col == 0){
					 if (cell[row][col+1] == 1) neighbors++;
					 if (cell[row+1][col] == 1) neighbors++;
					 if (cell[row+1][col+1] == 1) neighbors++;
				 }
				 if (col == colSize - 1){
					 if (cell[row][col-1] == 1) neighbors++;
					 if (cell[row+1][col] == 1) neighbors++;
					 if (cell[row+1][col-1] == 1) neighbors++;
				 }
				 else{
					 if (cell[row][col+1] == 1) neighbors++;
					 if (cell[row][col-1] == 1) neighbors++;
					 if (cell[row+1][col+1] == 1) neighbors++;
					 if (cell[row+1][col] == 1) neighbors++;
					 if (cell[row+1][col-1] == 1) neighbors++;
				 }
			 }
			 else if (row == rowSize - 1){
				 if (col == 0){
					 if (cell[row-1][col] == 1) neighbors++;
					 if (cell[row-1][col+1] == 1) neighbors++;
					 if (cell[row][col+1] == 1) neighbors++;
				 }
				 if (col == colSize - 1){
					 if (cell[row][col-1] == 1) neighbors++;
					 if (cell[row-1][col] == 1) neighbors++;
					 if (cell[row-1][col-1] == 1) neighbors++;
				 }
				 else{
					 if (cell[row][col+1] == 1) neighbors++;
					 if (cell[row][col-1] == 1) neighbors++;
					 if (cell[row-1][col+1] == 1) neighbors++;
					 if (cell[row-1][col] == 1) neighbors++;
					 if (cell[row-1][col-1] == 1) neighbors++;
				 }
			 }
			 else if (col == 0){
				 if (cell[row+1][col] == 1) neighbors++;
				 if (cell[row+1][col+1] == 1) neighbors++;
				 if (cell[row][col+1] == 1) neighbors++;
				 if (cell[row-1][col+1] == 1) neighbors++;
				 if (cell[row-1][col] == 1) neighbors++;
			 }
			 else if (col == colSize - 1){
				 if (cell[row][col-1] == 1) neighbors++;
				 if (cell[row-1][col] == 1) neighbors++;
				 if (cell[row-1][col-1] == 1) neighbors++;
				 if (cell[row+1][col] == 1) neighbors++;
				 if (cell[row+1][col-1] == 1) neighbors++;
			 }
			 else{
				if (cell[row-1][col-1] == 1) neighbors++;
				if (cell[row-1][col] == 1) neighbors++;
				if (cell[row-1][col+1] == 1) neighbors++;
				if (cell[row][col-1] == 1) neighbors++;
				if (cell[row][col+1] == 1) neighbors++;
				if (cell[row+1][col-1] == 1) neighbors++;
				if (cell[row+1][col] == 1) neighbors++;
				if (cell[row+1][col+1] == 1) neighbors++;
				}
			 // apply the rules of the game, determining births and deaths
             if (cell[row][col] == 1 && neighbors < 2)
                newLife[row][col] = 0;
             else if (cell[row][col] == 1 && neighbors > 3)
                newLife[row][col] = 0;
             else if (cell[row][col] == 1 && (neighbors == 2 || neighbors == 3))
                newLife[row][col] = 1;
             else if (cell[row][col] == 0 && neighbors == 3)
                newLife[row][col] = 1;
		 }
	 }
I haven't take a real careful look, but I think that might work. Give it a go...
 

Similar threads

Comp Sci Call by address in C/C++, how does it work?
  • · Replies 3 ·
Replies
3
Views
1K
Comp Sci I'm not understanding Parameterized Constructors in C++
  • · Replies 2 ·
Replies
2
Views
2K
Comp Sci Call by reference C++ confusion
  • · Replies 8 ·
Replies
8
Views
2K
Comp Sci Help with coin game C++ assignment?
  • · Replies 6 ·
Replies
6
Views
3K
Comp Sci Using C++ to find the minimum number of something
  • · Replies 3 ·
Replies
3
Views
2K
Comp Sci How Can C++ Function Overloading Simplify Gravity Calculations?
  • · Replies 8 ·
Replies
8
Views
2K
Comp Sci C++ Why is my function printing TWICE?
  • · Replies 3 ·
Replies
3
Views
7K
Comp Sci C++ program to read an input file with multiple headers
  • · Replies 15 ·
Replies
15
Views
3K
Comp Sci How Does a Boolean Variable Impact Program Functionality in C++?
  • · Replies 2 ·
Replies
2
Views
2K
Comp Sci How do you read two files in the same program in C++?
  • · Replies 23 ·
Replies
23
Views
9K