C/C++ - esercizio C - vettore e matrice

salve a tutti!
sono nuovo del sito, avrei un quesito da proporre a voi che sicuramente siete più esperti.
Ho quest'esercizio:
In un file binario è memorizzata una sequenza non ordinata di numeri(pari e dispari);
il numero di questi interi è dispari;
dichiarare, chiamare e definire opportune funzioni che sono in grado di allocare in memoria dinamica, una matrice quadrata la cui dimensione è uguale all'elemento che sta al centro della sequenza;
inizializzare la matrice con tutti gli interi presenti nel file (escluso l'intero che stabilisce la dimensione);
riempire le restanti celle della matrice allocata con zero.

ho abbozzato qualche riga di codice ma... non funge; qualcuno di voi può darmi una mano?
vi ringrazio in anticipo

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

int** carica(int*,int***);
void stampa(int,int***);  

int main(void)
{
	
	int** matrice=NULL;
	int dim=0;
	matrice=carica(&dim,&matrice);
	stampa(dim,&matrice);
	return 0;
}

int** carica(int* dim, int*** mat)
{
FILE* fp;
int i,j,ele;
int conta=0;
int k=0;
int z=0;  // indice del vettore
int* vett;

fp=fopen("immagine.dat","rb");

while(!feof(fp))
	conta++;  //voglio sapere il numero degli elementi

conta= conta/2;  // ho il numero degli elementi della prima parte

rewind(fp); 

for(i=0;i<conta+1;i++)
	fread(dim,sizeof(int), 1, fp);

rewind(fp);

//allocazione dinamica vettore
conta=conta*2;    // vettore di soli elementi escluso l'elemento centrale del file binario
vett=malloc(sizeof(int)*conta);
i=0;

for(;i<conta/2;i++)
	fread(&vett[i],sizeof(int),1,fp);

	fseek(fp,4,1); //salto i 4 byte dell'elemento centrale

	for(;i<conta/2;i++)
		fread(&vett[i],sizeof(int),1,fp);

	fclose(fp);
//allocazione dinamica matrice

*mat=malloc((*dim)*sizeof(int*));

	for(i=0;i<*dim;i++)
		*mat[i]=malloc(sizeof(int)*(*dim));


/*inserimento in matrice*/


for(i=0;i<*dim && z<conta;i++)
	{
		
		for(j=0;j<*dim && z<conta;j++)
			{
			(*mat)[i][j]=vett[z];
			z++;
			}
		
	}

	if(z==(*dim)*(*dim))     //caso particolare in cui il numero degli elementi dell'array concide esattamente con gli elementi della matrice
		return *mat;

		
	else if(j==*dim)
			{
				i++;    // altrimenti passa alla nuova  riga
				j=0;
				if(i==*dim)
					return *mat;
			}

// ora avrò i e j corrispondenti alla posizione dove comincia l'assegnamento degli zeri


	while(j!=*dim)
	{
		(*mat)[i][j]= 0; // completo la riga di zeri
		j++;
	}


for(;i<*dim;i++)
	{
		for(j=0;j<*dim ;j++)
			{
			(*mat)[i][j]=0;
			}
	}
return *mat;
 
}

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

Ciao!!!

Premetto che non ho visto per bene il codice, comunque i primi errori che mi sono saltati all'occhio sono i seguenti:

while(!feof(fp))
        conta++;

in questo modo il puntatore al file rimarrà sempre all'inizio, per scorrere il file devi fare, almeno, una lettura fittizia.

Poi non mi spiego un'altra cosa perché ritorni il puntatore alla matrice? Stai passando la matrice per indirizzo quindi non c'è bisogno di far ritornare alcunché, inoltre stai commettendo un errore nell'allocazione della matrice, piccolo suggerimento ricordati la precedenza degli operatori.

Poi non mi è chiara tutta la parte finale della funzione carica, ma probabilmente questo è dovuto al fatto che non ho ben capito l'esercizio, se puoi posta la traccia.

allora....
la traccia è quella che ho scritto prima; cerco di spiegarla meglio.

Allora io ho in un file binario una sequenza di numeri. La sequenza è dispari.
L'elemento centrale(medio) della sequenza, deve essere l'elemento che genererà la matrice quadrata.
Nella matrice generata dinamicamente dovrò allocare prima la sequenza dei numeri (tranne il numero centrale) e poi se avanzano dei posti, in quelli restanti inserire zero.
Alla fin fine stampare a video o a file la matrice.
Esempio:
ho memorizzato in un file binario questa sequenza di 5 numeri:
1 2 3 4 5
l'elemento centrale(medio) è il 3; 3 sarà il numero che allocherà la matrice quindi la matrice sarà 3x3 quindi di 9 "celle".
x x x
x x x
x x x
Nella matrice allocata dinamicamente, dovrò inserire prima la sequenza dei numeri (o se vogliamo chiamarla vettore) [tranne l'elemento centrale] e dopo nei restanti posti zero.
Quindi se ho 9 posti la matrice sarà questa:
1 2 4
5 0 0
0 0 0
E poi stamparla a schermo o a file.

Spero di esser stato più chiaro....

Attendo tue...
ti ringrazio per l'aiuto!

allora io farei così

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

#define DIM 5

void carica(int*, int***);
void stampa(int, int**);

int main(void)
{
    int **matrice=NULL;
    int dim=0, i;
    int vet[DIM];
    FILE *fp;

    for(i=0; i<DIM; i++){
        printf("\nInserire un numero: ");
        scanf("%d", &vet[i]);
    }

    fp=fopen("immagine.dat", "wb");

    fwrite(vet, sizeof(int), DIM, fp);
    fclose(fp);

    printf("\nFile creato...\n");
    getchar();

    carica(&dim, &matrice);
    stampa(dim, matrice);
    return 0;
}

void carica(int* dim, int*** mat)
{
    FILE* fp;
    int i,j;
    int conta=0;
    int z=0;
    int* vett;

    fp=fopen("immagine.dat","rb");

    while(!feof(fp)){
        conta++;  //voglio sapere il numero degli elementi
        fread(dim, sizeof(int), 1, fp);
    }

    conta--;
    conta= conta/2;  // ho il numero degli elementi della prima parte

    rewind(fp);

    for(i=0;i<conta+1;i++)
        fread(dim,sizeof(int), 1, fp);

    rewind(fp);

//allocazione dinamica vettore

    conta=(conta*2);    // vettore di soli elementi escluso l'elemento centrale del file binario
    vett=malloc(sizeof(int)*conta);
    i=0;

    for(;i<conta/2;i++)
        fread(&vett[i],sizeof(int),1,fp);

    fseek(fp,sizeof(int),1); //salto i 4 byte dell'elemento centrale

    for(;i<conta;i++)
        fread(&vett[i],sizeof(int),1,fp);

//allocazione dinamica matrice
    fclose(fp);

    *mat=(int **)malloc((*dim)*sizeof(int*));

    for(i=0;i<*dim;i++)
        (*mat)[i]=(int *)malloc(sizeof(int)*(*dim));

/*inserimento in matrice*/

    for(i=0; i<*dim; i++){
        for(j=0; j<*dim; j++){
            (*mat)[i][j]=0;
        }
    }

    for(i=0;i<*dim && z<conta;i++){
        for(j=0;j<*dim && z<conta;j++){
            (*mat)[i][j]=vett[z];
            z++;
        }
    }
}

void stampa(int dim, int** mat)
{
    int i,j;

    printf("\n\n");

    for(i=0;i<dim;i++){
        for(j=0;j<dim;j++){
            printf("%d\t", mat[i][j]);
        }
        printf("\n\n");
    }
}

ho modificato un po' il main per creare di volta in volta il file, se vuoi puoi togliere quella parte.
Dimmi se c'è qualcosa che non capisci.

perfetto... ho capito come hai ragionato...
soltanto che, al posto di rendera statica la dimensione e cioè al posto di definirla con define, non si può dire:
inserire il numero di componenti del vettore?
e quindi poi di li prendere il tutto...?
ti ringrazio per l'aiuto..

Certo che si può...

se non ti chiedo troppo... puoi gentilmente... farmi veder come...?

Puoi usare l'allocazione dinamica, esattamente come hai fatto per il vettore nella funzione carica.

Provaci se poi non ci riesci chiedi pure...