C ignores "if" instructions

Question

I'm having a problem with a program I have made recently. Basically, it's a simple version of the John Conway's game of life, but it's not working properly. The problem is in the code that reads the state of a cell and its neighbours and decides the future state of that cell. Here's that part of the code (it's a bit long):

#include<stdio.h>
#include<conio.h>

//Game grid size
#define SIZE 15

//Cell state (wall is a special state. It protects the other cells from garbage data of the heap memory)
enum cellState {dead,alive,wall};

//Function prototypes
int** load(int**);
void process(int**);

int main(){

    //Game grid (2-D matrix) and its memory allocation
    int** grid;

    grid=(int**)calloc(SIZE+2,sizeof(int*));
    for(int cont=0;cont<SIZE+2;cont++){
        *(grid+cont)=(int*)calloc(SIZE+2,sizeof(int));
    }

    load(grid);
    getch();
    process(grid);
    getch();
}

//Grid loading function
int** load(int** grid){

    int type;
    srand(12345);
    for(int cont=0;cont<SIZE+2;cont++){
        for(int cont2=0;cont2<SIZE+2;cont2++){
            if(cont==0||cont==TAMANO+1||cont2==0||cont2==TAMANO+1){
                *(*(grid+cont)+cont2)=wall;
            }
            else{
                //Cell type decision
                type=(int)((rand()*2+1)/32767);
                if(type==dead){
                    *(*(grid+cont)+cont2)=dead;
                }
                else if(type==alive){
                    *(*(grid+cont)+cont2)=alive;
                }
            }
        }
    }
    //Grid impression
    for(int cont=0;cont<SIZE+2;cont++){
        for(int cont2=0;cont2<SIZE+2;cont2++){
            if(*(*(grid+cont)+cont2)==wall){
                printf("W ");
            }
            else if(*(*(grid+cont)+cont2)==dead){
                printf(". ");
            }
            else if(*(*(grid+cont)+cont2)==alive){
                printf("C ");
            }
        }
        printf("\n");
    }
    return(grid);
}


void process(int** grid){

    //Temporary grid that saves the next state of a cell
    int** gridTemp;
    //Generations (turns) counter and live neighbours counter
    int generations=0,liveNeighbours=0;
    gridTemp=(int**)calloc(SIZE+2,sizeof(int*));
    for(int cont=0;cont<SIZE+2;cont++){
        *(gridTemp+cont)=(int*)calloc(SIZE+2,sizeof(int));
    }

    for(int cont=0;cont<SIZE+2;cont++){
        for(int cont2=0;cont2<SIZE+2;cont2++){
            if(cont==0||cont==SIZE+1||cont2==0||cont2==SIZE+1){
                *(*(gridTemp+cont)+cont2)=wall;
            }
        }
    }

    //Processing loop
    while(generations<100){

        system("cls");

        for(int cont=1;cont<SIZE+1;cont++){
            for(int cont2=1;cont2<SIZE+1;cont2++){
                for(int comp1=-1;comp1<2;comp1++){
                    for(int comp2=-1;comp2<2;comp2++){
                        if(comp1==0&&comp2==0) continue;
                        else{
                            //Here, we read the state of the neighbour cells of a certain cell
                            if(*(*(grid+cont)+cont2)==dead){
                                if(*(*(grid+cont+comp1)+cont2+comp2)==alive){
                                    liveNeighbours+=1;
                                }
                            }
                            else if(*(*(grid+cont)+cont2)==alive){
                                if(*(*(grid+cont+comp1)+cont2+comp2)==alive){
                                    liveNeighbours+=1;
                                }
                            }
                        }
                    }
                }
                //Future state calculation. Here is where the code fails. This if compares the state of a certain cell and the "dead" enumeration
                if(*(*(grid+cont)+cont2)==dead){
                    if(liveNeighbours==3){
                        *(*(gridTemp+cont)+cont2)==alive;
                    }
                    else{
                        *(*(gridTemp+cont)+cont2)==dead;
                    }
                }
                if(*(*(grid+cont)+cont2)==alive){
                    //It also fails here. This if checks the value of the liveNeighbours variable
                    if(liveNeighbours>=2&&liveNeighbours<=3){
                        *(*(gridTemp+cont)+cont2)==alive;
                    }
                    //And here too
                    if(liveNeighbours<2||liveNeighbours>3){
                        *(*(gridTemp+cont)+cont2)==dead;
                    }
                }
                liveNeighbours=0;
            }
        }
        //Here, the program copies the temporary grid onto the normal grid
        for(int cont=0;cont<SIZE+2;cont++){
            for(int cont2=0;cont2<SIZE+2;cont2++){
                *(*(grid+cont)+cont2)=*(*(gridTemp+cont)+cont2);
                if(*(*(grid+cont)+cont2)==wall){
                    printf("W ");
                }
                else if(*(*(grid+cont)+cont2)==dead){
                    printf(". ");
                }
                else if(*(*(grid+cont)+cont2)==alive){
                    printf("A ");
                }
            }
            printf("\n");
        }
        generations++;
        getch();
    }
    return;
}

Using the Dev-C++ debugging tool, I was able to see that the code fails at the points I have marked. Simply, it ignores the code in those "if" instructions, even if the condition is met.

I also rebuild this code a couple times and tried it in another compiler, and it also fails. Turbo-C++ says that the code in the bad if instructions has no effect.

Answer 1

In the code snippet:

                  if(liveNeighbours==3){
                                     *(*(gridTemp+cont)+cont2)==alive;
                                     }
                             else{
                                     *(*(gridTemp+cont)+cont2)==dead;
                                     }

You are not assigning the value 'alive' or 'dead' to the cell - you are checking if it's equal (because of the == comparison). I am pretty sure that is not what you intend to do?

the same thing happens in the other place where "the if statement fails":

             if(liveNeighbours>=2&&liveNeighbours<=3){
                                     *(*(gridTemp+cont)+cont2)==alive;
                                     }
                             //And here too
                             if(liveNeighbours<2||liveNeighbours>3){
                                     *(*(gridTemp+cont)+cont2)==dead;
                                     }

I think that replacing those four == signs with = will help.