Counter Isn't Working For My Game

[NU9yT05o]

I don't understand why my counter(In my display function) is giving me weird numbers. I will post what the output should be in the comments.

#include <iostream>
#include <fstream>
#include <iomanip>
using namespace std;

const int SIZE = 20;
void displayGrid( bool [][SIZE]);
void nextGeneration(bool [][SIZE], bool [][SIZE]);
int getNeighborCount(const bool [][SIZE], int, int);
void readGrid(bool [][SIZE]);
void initGrid(bool [][SIZE]);
int liveCellNeighbors(bool [][SIZE], int, int);
int deadCellNeighbors(bool [][SIZE], int, int);
int getTotalLive(bool [][SIZE], int, int);
int getTotalDead(bool [][SIZE], int, int);


int main()
{

  // Initilize the grid to all dead cells
  bool Grid[SIZE][SIZE];
  int row, col;

  // Prompt user for initially living cells. Ignore illegal inputs.
  readGrid(Grid);


  bool temp[SIZE][SIZE];   // temporary workspace for computing next generation
  for (int count = 0; count <= 5; count++)
  {
       displayGrid(Grid);
       nextGeneration(Grid, temp);

  };




  return 0;
}




int getTotalLive(bool World[][SIZE], int row, int col)
    {
        int numLive=0;


        for(int i = 0 ; i < row ; i++)
        {
            for(int j = 0 ; j < col ; j++)
            {
                if(World[row][col] == )
                    numLive++;
            }
        }


        return numLive;
    }




int getTotalDead(bool World[][SIZE], int row, int col)
    {
        int numDead = 0;

        for(int i = 0 ; i < row ; i++)
        {
            for(int j= 0 ; j < col ; j++)
            {
                if(World[row][col]== false)
                    numDead++;
            }
        }


        return numDead;
    }
int liveCellNeighbors(bool World[][SIZE], int row, int col)
{
    int neighbors;

    if(World[row][col]== true && World[row][col-1]==true && col-1>=0)
          {
          neighbors++;
          }
          if(World[row][col]== true && World[row+1][col-1]==true && row+1<3 && col-1>=0)
          {
          neighbors++;
          }
           if(World[row][col]== true && World[row+1][col]==true && row+1<3)
          {
          neighbors++;
          }
          if(World[row][col]== true && World[row][col+1]==true && col+1<SIZE)
          {
          neighbors++;
          }

         if(World[row][col]== true && World[row-1][col-1]==true && row-1>=0 && col-1>=0 )
          {
          neighbors++;
          }
          if(World[row][col]== true && World[row+1][col+1]==true && row+1<3 && col+1<SIZE)
          {
          neighbors++;
          }
          if(World[row][col]== true && World[row-1][col]==true && row-1>=0)
          {
          neighbors++;
          }
          if(World[row][col]== true && World[row-1][col+1]==true && row-1>=0 && col+1<SIZE)
          {
          neighbors++;
          }

   return neighbors;
}



int deadCellNeighbors(bool World[][SIZE], int row, int col)
{
    int neighbors;

    if(World[row][col]== true && World[row][col-1]==true && col-1>=0)
          {
          neighbors++;
          }
          if(World[row][col]== false && World[row+1][col-1]==true && row+1<3 && col-1>=0)
          {
          neighbors++;
          }
           if(World[row][col]== false && World[row+1][col]==true && row+1<3)
          {
          neighbors++;
          }
          if(World[row][col]== false && World[row][col+1]==true && col+1<SIZE)
          {
          neighbors++;
          }

         if(World[row][col]== false && World[row-1][col-1]==true && row-1>=0 && col-1>=0 )
          {
          neighbors++;
          }
          if(World[row][col]== false && World[row+1][col+1]==true && row+1<3 && col+1<SIZE)
          {
          neighbors++;
          }
          if(World[row][col]== false && World[row-1][col]==true && row-1>=0)
          {
          neighbors++;
          }
          if(World[row][col]== false && World[row-1][col+1]==true && row-1>=0 && col+1<SIZE)
          {
          neighbors++;
          }

   return neighbors;
}





void readGrid(bool World[][SIZE])
{
    ifstream infile("bacteria.txt");

    int numBacteria, row, col;

    initGrid(World);  //initialize grid

    infile >> row >> col;
    while (infile){
        World[row][col] = true;
        infile >> row >> col;
    }
    infile.close();
}

void initGrid(bool World[][SIZE])
{
    for (int row = 0; row < SIZE; row++){
        for (int col = 0; col < SIZE; col++){
            World[row][col] = false;
        }
    }
}

void displayGrid(bool World[][SIZE])
{
  cout << "  01234567890123456789" << endl;
    for (int row = 0; row < SIZE; row++){
        cout << setw(2) << row;
        for (int col = 0; col < SIZE; col++){
            if (World[row][col]){ //if true, cell is "alive"
                cout << "*";
            } else {             //if false, cell is "dead"
                cout << " ";
            }
        }
        cout << endl;
    }



cout<<"Total alive in row 10 = "<<getTotalLive(World, 10, SIZE)<<endl;
cout<<"Total alive in col 10 = "<<getTotalLive(World, SIZE, 10)<<endl;
cout<<"Total dead in row 16 = "<<getTotalDead(World, 16, SIZE)<<endl;
cout<<"Total dead in col 1 = "<<getTotalDead(World, SIZE, 1)<<endl;
cout<<"Total alive = "<<getTotalLive(World, SIZE, SIZE)<<endl;
cout<<"Total dead = "<<getTotalDead(World, SIZE, SIZE)<<endl;
}

// Declares a local array of states and sets it to the next generation
// by looping thru the object's World array, and for each cell calling
// the getNeighborCount function to see whether it should live or die.
// Once the temporary array is filled, it is copied over to the
// object's World array.
void nextGeneration(bool World[][SIZE], bool tempWorld[][SIZE])
{
  int neighborCnt;
  for (int i=0; i < SIZE; i++)
    for (int j=0; j < SIZE; j++) {
      neighborCnt = getNeighborCount(World,i,j);
      if (neighborCnt == 2)             // 2 live neighbors:
	tempWorld[i][j] = World[i][j];  // unchanged in next generation.
      else if (neighborCnt == 3)
	tempWorld[i][j] = true;         // 3 live neighbors:
                                        // alive in next generation

      else tempWorld[i][j] = false;      // 1, 4-8 living neighbors:
    }                                    // dead in next generation

  // copy tempWorld to World
  for (int i=0; i < SIZE; i++)
    for (int j=0; j < SIZE; j++)
      World[i][j] = tempWorld[i][j];
}

int getNeighborCount(const bool World[][SIZE], int row, int col)
// This function takes a row/col pair and counts the number
// of living neighbors for the specified cell.
{
//  1 2 3       These are the positions of the
//  4 x 5       neighbors of x. Each is checked
//  6 7 8       below for alive/dead.

  int cnt=0;

  if (row > 0) {
    if (col > 0 && World[row-1][col-1] == true)          // check 1
      cnt++;
    if (col < SIZE-1 && World[row-1][col+1] == true)     // check 3
      cnt++;
    if (World[row-1][col] == true)                       // check 2
      cnt++;

  }

  if (row < SIZE - 1) {
    if (col > 0 && World[row+1][col-1] == true)          // check 6
      cnt++;
    if (col < SIZE - 1 && World[row+1][col+1] == true)   // check 8
      cnt++;
    if (World[row+1][col] == true)                       // check 7
      cnt++;
  }

  if (col > 0 && World[row][col-1] == true)              // check 4
    cnt++;
  if (col < SIZE - 1 && World[row][col+1] == true)       // check 5
    cnt++;

  return cnt;
}

[Codermik]

Check line 55, what are you meant to be comparing with here?

In function liveCellNeighbors (line 83) you increment an uninitialized variable called neighbors, same with deadCellNeighbors