[C]Allocazione matrice dimensione 3

[mx92]

Voglio allocare dinamicamente una matrice di dimensione 3 passandola per indirizzo alla funzione.

Questo è il codice:

void alloca(unsigned char ****m,int r, int c, int p)
{ 
     int i,j;
     
     *m = malloc(r*sizeof(char*));
     
     for(i = 0; i < r; i++)
     {
           *m[i] = malloc(c*sizeof(char*));
           for(j = 0; j < c; j++)
                 *m[i][j] = malloc(p*sizeof(char));
     }
        
}

Al valore j = 1 da un errore di segmentazione che non riesco a capire come risolvere.
Posto il codice della funzione analoga (che non da alcun errore) dove la matrice non viene passata per indirizzo

unsigned char ***alloca(int r, int c,int p)
{ 
     int i,j;
     unsigned char ***m;
     
     m = malloc(r*sizeof(char*));
     
     for(i = 0; i < r; i++)
     {
        m[i] = malloc(c*sizeof(char*));
        for(j = 0; j < c; j++)
              m[i][j] = malloc(p*sizeof(char));
     }
        
     
        
     return m;
}

[oregon]

Il codice dovrebbe essere

void matalloc(unsigned char ****m, int r, int c, int p)
{ 
     int i,j;
     
     *m = (unsigned char ***)malloc(r * sizeof(unsigned char **));
     
     for(i = 0; i < r; i++)
     {
           (*m)[i] = (unsigned char **)malloc(c * sizeof(unsigned char *));
           
           for(j = 0; j < c; j++)
                 (*m)[i][j] = (unsigned char *)malloc(p * sizeof(unsigned char));
     }       
}

Fai attenzione all' unsigned char al posto del char

Chiaramente, mancano tutti i controlli sulla effettiva riuscita di tutte le malloc ... dovrai aggiungerli tu ...

[mx92]

Grazie della risposta innanzitutto.
Comunque anche così non va ma lo immaginavo dato che so che in C la malloc fa in automatico il cast

[oregon]

Originariamente inviato da mx92
Comunque anche così non va

Che vuol dire "non va" ?

ma lo immaginavo dato che so che in C la malloc fa in automatico il cast

Sì, ma quando scrivi sizeof(char) è meglio essere precisi

Questo comunque non c'entra. Il codice funziona a meno che tu non lo abbia modificato e/o usato male.

[mx92]

Ok ho notato che il problema erano le parentesi in cui deve andare *m. Ora però ho un altro problema

Praticamente è come se allocasse la matrice in modo che sia m[r][r][p]
Per esempio in casi in cui c > r quando vado a leggere per esempio l'elemento m[0][r][0] mi da errore di segmentazione

[oregon]

Originariamente inviato da mx92
Ok ho notato che il problema erano le parentesi in cui deve andare *m. Ora però ho un altro problema

T'avevo detto che non avevi usato correttamente il codice.

Praticamente è come se allocasse la matrice in modo che sia m[r][r][p]
Per esempio in casi in cui c > r quando vado a leggere per esempio l'elemento m[0][r][0] mi da errore di segmentazione

A questo punto devi mostrare il codice che utilizzi altrimenti non si può determinare il problema ...

[mx92]

Allora questi sono il codice del main e il codice che uso per allocare nella matrice, per assegnarle dei valori

int main()
{
    FILE *fp;
    char nome_f[80];
    unsigned char ***mat;
    
    char pr;
    int a,l,offset;
    
    printf("Inserisci il nome del file su cui operare: ");
    gets(nome_f);
    
    fp = fopen(nome_f,"rb");
    

    if(fp == NULL)
    {
        printf("File non trovato!\n");
        system("pause");
    }
    else
    {   
        carica_mat(&mat,&a,&l,&pr,&offset,fp);
  
        ingrandisci(fp,nome_f,&mat,a,l,pr,offset);
    }
    
    close(fp);
    
    system("pause");

    return 0;
}

void alloca(unsigned char ****m,int r, int c, int p)
{ 
     int i,j;
     
     *m = malloc(r*sizeof(unsigned char*));
     if(*m == NULL)
           printf("Errore 1!!!!");
     
     for(i = 0; i < r; i++)
     {
        (*m)[i] = malloc(c*sizeof(unsigned char*));
        if(*m == NULL)
           printf("Errore 2!!!!");
        
        for(j = 0; j < c; j++)
        {
              (*m)[i][j] = malloc(p*sizeof(unsigned char));
              if(*m == NULL)
                    printf("Errore 3!!!!");
        }
     }
     
        
} 

void carica_mat(unsigned char ****m,int *r, int *c, char *p, int *offset, FILE *f)
{
     int i,j,k;
     
     dim_imm(f,r,c,p,offset);
     alloca(m,*r, *c, *p);
     
     rewind(f);
     fseek(f,*offset,SEEK_CUR);
     
     for(i = 0; i < *r; i++)
           for(j = 0; j < *c; j++)
                 for(k = 0; k < *p; k++)
                       fread(m[i][j][k], sizeof(char),1,f);
     
}

void dim_imm(FILE *f, int *r, int *c, char *p, int *offset)
{
     rewind(f);
     
     fseek(f,10,SEEK_CUR);
     fread(offset,sizeof(int),1,f);
     
     fseek(f, 4, SEEK_CUR);
     fread(c, sizeof(int), 1, f);
     fread(r, sizeof(int), 1, f);
     
     fseek(f,2,SEEK_CUR);
     fread(p,sizeof(char),2,f);
     *p /= 8;
     
     rewind(f);

     return;
}

[Who am I]

Non hai letto il post di oregon, la tua funzione alloca è sempre la stessa.

[mx92]

Originariamente inviato da Who am I
Non hai letto il post di oregon, la tua funzione alloca è sempre la stessa.

E' sempre la stessa perchè la modifica di Oregon (il cast della malloc) l'ho già provata ma il risultato non cambia.

[oregon]

Originariamente inviato da mx92
E' sempre la stessa perchè le modifiche di Oregon le ho già provate ma il risultato non cambia.

Certo che questa è bella.

Perché chiedi aiuto ?

La funzione che alloca la matrice che ti ho inviato è corretta, ma tu non l'hai usata o usata male. Ad esempio, nella prima riga hai scritto

*m = malloc(r*sizeof(unsigned char*))

e non

*m = malloc(r*sizeof(unsigned char **))

come dovrebbe essere.

Gli ultimi due confronti con NULL sono sbagliati perché non testano i puntatori appena allocati ma sempre il primo.

E non ho controllato il resto del codice, ma se ritieni che ti dia suggerimenti sbagliati, è anche inutile controllarlo.