Understanding memory allocation and a core dumped error

Question

I'm a bit confused with memory allocation.

I want to fill a structure Sudoku with random number and then check if a box of 9 numbers are correct.

#define SUDOKU_SIZE 9 
typedef struct 
{ 
   int grid[SUDOKU_SIZE][SUDOKU_SIZE]; 
} sudoku_t;

int main(int argc, char const *argv[]){
    sudoku_t *s=malloc(sizeof s);
    s->grid[0][0]=6;//manualy setting the value of the sudoku
    ...
    s->grid[8][8]=7;
    fill_sudoku_test(s);//fill s, a feasible Sudoku with random number
    int k, l;
    for(k=0;k<SUDOKU_SIZE;k+=3){
        for(l=0;l<SUDOKU_SIZE;l+=3){
            if(correct_box(s,k,l))//check if a box of 3 by 3 contains 9 differents numbers
                printf("Box correct at position :%d and %d\n",k,l);
         }
    }
    free(s);
    return EXIT_SUCCESS;
}

When I compile this code, I got a core dumped error.

If somebody got a solution, I'm interested

EDIT

Here's the others functions :

void fill_sudoku_test(sudoku_t *s){
   int k, l;
   time_t t;
   srand((unsigned) time(&t));
   for(k=0;k<SUDOKU_SIZE;k++){
       for(l=0;l<SUDOKU_SIZE;l++){
           if(!(s->grid[k][l])) {
               s->grid[k][l]=rand()%SUDOKU_SIZE+1;
           }            
       }
   }
}


int correct_tab(int value[]){
   int i;
   int tab[9];
   for(i=0;i<SUDOKU_SIZE;i++){
      tab[i]=0;
   }
   for(i=0;i<SUDOKU_SIZE;i++){
      if(tab[value[i]-1]==1){
        return 0;
      }
      else{
        tab[value[i]-1]=1;
      }
   }
   return 1;
}

int correct_box(sudoku_t *s, int i, int j){
   int tab[SUDOKU_SIZE];
   int count=0;
   int k,l;
   for(k=0;k<3;k++){
      for(l=0;l<3;l++){
         tab[count]=s->grid[i+k][j+l];
      }
   }
   return (correct_tab(tab));
}

Answer 1

sudoku_t *s=malloc(sizeof s);

should be

sudoku_t *s=malloc(sizeof(sudoku_t));

or

sudoku_t *s=malloc(sizeof(*s));

EDIT

in function correct_tab the value[i] can be (and is) 0. Then:

tab[value[i]-1]=1;

and

if(tab[value[i]-1]==1)

access the array out of bounds.

EDIT 2

In correct_tab value array is not intited for the whole SUDOKU_SIZE then some values of array are undefined.

You can, at least, declare it as:

int tab[SUDOKU_SIZE] = {0};

EDIT3

To answer to your comments:

Your init is correct: init numbers are between 1 to 9.

The problem is that correct_tab is called from correct_box is passing tab, a local (stack allocated) array. This means 1 main thing:

• its values are not itited to 0. Those value are randoms due to the stack allocation.

using my EDIT2 code you can set 0 for all values of the array.

BTW your correct_tab function loops the whole tab array, where only some values are extracted from your sudocu_t struct matrix. This happend due to:

1. count variable into correct_box function is always 0. You must inc it each time you set a value into tab array.
2. You should pass the count value to correct_tab function to allow to loop on the real inserted values only.

Answer 2

When you allocate:

sudoku_t *s=malloc(sizeof s);

This only allocates memory sufficient to store a pointer. You probably mean:

sudoku_t *s=malloc(sizeof(*s));

Beyond that, you will need to use a debugger to identify which part of the code actually triggered the segmentation fault.

Answer 3

First problem lies in this line:

sudoku_t *s=malloc(sizeof s);

which means malloc is allocating memory equal to the size of pointer, which could be 4 bytes or 8 bytes depending on the machine.

Ideally what u r expecting is allocating the size of structure, so this should be:

sudoku_t *s = (sudoku_t *) malloc(sizeof(sudoku_t));