C/C++ - [C]Lettura da file e scrittura su matrice allocata dinamicamente

Ho un file di interi e sò solo che il numero totale degli interi è dispari. Della sequenza del file devo leggere l'intero centrale (ad es. se ho 13 interi devo leggere il 7). Il valore di questo intero è la dimensione della matrice quadrata che devo allocare dinamicamente. Dopo averla allocata dinamicamente, la devo riempire con gli interi del file, tranne quello che mi ha dato la dimensione. Se gli interi del file sono di meno degli elementi che può contenere la matrice, allora quelli rimanenti gli inizializzo a zero.

Non ho errori in compilazione, ma in esecuzione. Mi dà errore di segmentazione nella riempi_matrice sulla fread al terzo giro del ciclo

Ecco il codice che ho scritto:

#include<stdio.h>
#include<stdlib.h>

void alloca_matrice(int***,int*,int*);
void riempi_matrice(int***,int,int);
void stampa(int**,int);

int main()
{
    int** matrice=NULL;
    int dimensione=0;
    int elementi=0;
    
    alloca_matrice(&matrice,&dimensione,&elementi);
    riempi_matrice(&matrice,dimensione,elementi);
    stampa(matrice,dimensione);
    system("pause");
    return 0;    
}

void alloca_matrice(int***m,int*dim,int*num)
{
     FILE* fp=NULL;
     int i;
     int end=0;
     fp=fopen("seq.dat","rb");
     fseek(fp,0,SEEK_END);
     end=ftell(fp);
     fseek(fp,0,SEEK_SET);
     while((ftell(fp))!=end)
     {
                            (*num)++;
                            fseek(fp,sizeof(int),SEEK_CUR);
                            printf("2");
     }
     *dim=((*num)/2);
     fseek(fp,(*dim)*sizeof(int),SEEK_SET);
     fread(dim,sizeof(int),1,fp);
     if(((*dim)*(*dim))<(*num))
     {
         printf("Il file contiene più interi di quanti ne puo' contenere la matrice");
         exit(1);
     }
     else
     {    
          *m=malloc((*dim)*sizeof(int));
          for(i=0;i<(*dim);i++);
          {
                         (**m)[i]=malloc((*dim)*sizeof(int));
          }
      }    
     fclose(fp);
     printf("1");
     printf("\nnum= %d", *num);
     printf("\ndim= %d", *dim);
}

void riempi_matrice(int*** m,int dim,int num)
{
     FILE*fp=NULL;
     int i,j;
     int flag=0;
     fp=fopen("seq.dat","rb");
     do
     {
          for(i=0;i<dim;i++)
          {
                    for(j=0;j<dim;j++)
                    {
                        if(flag==((num/2)+1))
                        {}
                        else
                        {
                            fread((&m)[i][j],sizeof(int),1,fp);
                            flag++;
                            printf("\n%d    %d      %d        %d",i,j,num,flag);
                        }
                    }
          }    
     }
     while((i+j)<num);
     for(;i<dim;i++)
     {
                    for(;j<dim;j++)
                    {
                        (*m)[i][j]=0;
                    }
     }        
     fclose(fp);
     printf("2");
}

void stampa(int** m,int dim)
{
     int i,j;
     for(i=0;i<dim;i++)
     {
                       for(j=0;j<dim;j++)
                       {
                                         printf("%d", m[i][j]);
                       }
                       printf("/n");
     }
}

Un triplo puntatore? LOL Credo sia la prima volta che ne vedo uno, il che mi fa meditare sulla vita, l'universo e tutto il resto.
Comunque, l'errore di segmentazione, secondo me, è quasi sicuramente dovuto al triplo puntatore, non perché tu non li sappia usare, ma perché è abbastanza arduo non perderne il controllo. Per questo ti consiglio di linearizzare la matrice, con cui è sufficiente un singolo puntatore.

int* m;
// m indica l'indirizzo del primo elemento della matrice
m = (int*)malloc(sizeof(int) * dim * dim);
// l'elemento (i, j) nella matrice si trova alla posizione i * dim + j dell'array m
int item = *(m + i * dim + j); // oppure m[i * dim + j]
// per ottenere l'indirizzo dell'elemento (i, j) puoi fare:
int* addr = &(m[i * dim + j]); // oppure m + i * dim + j

Se vuoi passare la matrice per riferimento nella tua funzione, allora un puntatore doppio è sufficiente.

Per quanto riguarda il tuo codice:

fread((&m)[ i ][j],sizeof(int),1,fp);

Se consideriamo m come un puntatore ad array di array, allora per passare l'indirizzo del j-esimo elemento dell'array i-esimo, se non sbaglio i conti, si fa in questo modo:

fread(&((*m)[ i ][j]),sizeof(int),1,fp);

m è il puntatore al puntatore al primo elemento dell'array di array, quindi *m è il puntatore al primo elemento dell'array. Perciò (*m)[ i ], oppure ((*m) + i) indica l'i-esimo elemento dell'array, che è a sua volta un puntatore al primo elemento del secondo array. Risulta infine che (*m)[ i ][j] punta all'elemento j dell'array i-esimo. Perciò il suo indirizzo è &((*m)[ i ][j]).
O forse no... non mi sono mai piaciuti tanto i puntatori.