Segmentation Fault by trying to access binary file

Question

My program stores matrix in binary files, when I try to "load" them during the same use of the program, everything works well.

However, when I close the program and use it later, it's impossible to access to the same files and I get a Segmentation fault (core dumped) error.

Here's the function that "loads" the matrixes :

void Loading(int mat**){
  char* name = malloc(sizeof(char)*20);
  printf("Enter name of the file");
  scanf("%s",name);
  FILE* file=fopen(name,"rb");
  if (file==NULL){
    printf("error opening file");
    exit(0);
  }
  fread(mat,sizeof(int)*M*M,1,file);
  fclose(fichier);
}

where M is a constant.

Again it works perfectly when I store/load mutliple times during the same use of the program

sorry for the mistakes I am not an english speaker

Answer 1

As presented, the question is missing key elements to allow a full analysis, nor a complete answer. But with what is shown, here are some suggestions:

1) The reason(s) for your segmentation fault cannot be identified with absolute certainty because some of the pieces are missing from your post. However, given the fact that it works sometimes, and not others, suggests undefined behavior is playing a part. If I were to guess at the source of undefined behavior, it would be that you are passing around a double pointer variable int **mat, when only a single pointer variable int *mat is necessary (see prototype of fread() below.), further leading me to believe that memory for mat has not been correctly created. I suggest changing:

void Loading(int mat**) // double pointer is not needed here

to

void Loading(unsigned int mat*) //and memory allocation method adjusted accordingly.   

(See reason for unsigned in 3) below.)

2) The prototype for the function fread() is:

size_t fread (void *Buffer, size_t Element_Size, size_t Number_of_Elements, FILE *Stream);

In your call:

fread(mat,sizeof(int)*M*M,1,file);

Arguments 2 & 3 appear to be reversed. It should probably be written:

fread(mat, sizeof(unsigned int), M*M, file);

3) Why unsigned int verses int when working with binary data?:

• Your post is not explicit on how the data is written to the file, or exactly what format it is in, but generally, when working with binary data, it is better to stick with unsigned types for the reasons listed here.

Answer 2

You have a pointer to your buffer for matrix int **mat. The problem is, that this doesn't point to single continuous place in memory. int mat** is a pointer to array of pointers to int. This is a place in memory that should contain more pointers one stored after another. Each of them (int*) then should point into different arrays, that would finally contain array of integers.

Basically you use command fread to write whole data into the array of pointers. Maybe you don't have enough space to store your data at all. Even if you would, you need another kind of pointer. If you have one continuous array, you could point to it using int *. Then you would pick some element by calculating an index.

int *mtx = (int*) malloc(M*M*sizeof(int);
int x = 2, y = 3;
int index = y*M+x;
mtx[index] = 123; // write to matrix coordinates 2,3

You could use fread with this kind of buffer with no problem, just check how are matrix elements indexed in your input file, maybe the x,y is swapped.