allocazione dinamica di array multidimensionali

[gianluca]

Ciao a tutti,
ho bisogno di allocare dinamicamente una matrice tridimensionale. Ho
provato in questo modo:

double ***mat;

mat=(double***)malloc(ndimension*(sizeof(double));

ma purtroppo ottengo un errore a run time.
Non riesco a capire come devo fare.
Grazie in anticipo a chi può aiutarmi

gianluca

[Giacomo Degli Esposti]

gianluca wrote:
> Ciao a tutti,
> ho bisogno di allocare dinamicamente una matrice tridimensionale. Ho
> provato in questo modo:
>
> double ***mat;
>
> mat=(double***)malloc(ndimension*(sizeof(double));

non e' sufficiente: devi allocare un array di puntatori, poi
per ognuno di questi allocare un array di puntatori e per ognuno di
questi devi allocare un array di double.

// non testato
// alloca l'equivalente di mat[NX][NY][NZ]
mat = malloc( NX * sizeof( double ** ) );
for( i = 0; i < NX; i ++ ){
mat[i] = malloc( NY * sizeof (double * ) );
for( j = 0; j < NY; j++ ){
mat[i][j] = malloc( NZ * sizeof double );
}
}

Una minuzia: in C non occorre il cast prima di malloc. Meno cast inutili
metti nel tuo codice e meno rischi di inserire errori subdoli! :)

> ma purtroppo ottengo un errore a run time.

Ricordati sempre di riportare che errore ottieni di preciso! Cosi' ci
diventa piu' facile aiutarti! :)

> Non riesco a capire come devo fare.

> Grazie in anticipo a chi puņ aiutarmi

ciao
Giacomo

[Andrea Laforgia]

On Sat, 9 Aug 2008 06:23:50 -0700 (PDT), gianluca
<geon...@gmail.com> wrote:

>Ciao a tutti,
>ho bisogno di allocare dinamicamente una matrice tridimensionale. Ho
>provato in questo modo:
>
>double ***mat;
>
>mat=(double***)malloc(ndimension*(sizeof(double));

Il cast sul valore di ritorno di malloc() non si usa in C (mentre è
obbligatorio in C++). Se vuoi allocare una matrice MxNxP scriverai:

double ***mat = malloc(M * sizeof(double**));
...
size_t i, j;
for (i=0; i<M; i++) {
mat[i] = malloc(N * sizeof(double*));
for (j=0; j<P; j++) {
mat[i][j] = malloc(P * sizeof(double));
...
}
}

[Andrea Laforgia]

On Sat, 09 Aug 2008 16:00:21 +0200, Andrea Laforgia
<a.laf...@andrealaforgia.it.invalid> wrote:

> for (j=0; j<P; j++) {

Errata Corrige: j<N

[Andrea Laforgia]

On Sat, 09 Aug 2008 13:49:36 GMT, Giacomo Degli Esposti
<pad...@iperboleTOGLIERE.bologna.it> wrote:

> mat[i][j] = malloc( NZ * sizeof double );

sizeof(double)

Ci vogliono le parentesi per i tipi.

[Giacomo Degli Esposti]

Uh, si'. Grazie. In effetti il mio codice era "non testato"

ciao
Giacomo

[gianluca]

On 10 Ago, 11:59, Giacomo Degli Esposti

grazie a tutti,
ho risolto grazie ai vostri suggerimenti

[Pleg]

Ci sono vantaggi/svantaggi prestazionali nell'usare questa tecnica rispetto
all'allocare un array di double monodimensionale di dimensione MxNxP e
convertire ogni volta gli indici 3D nella posizione 1D?

Pleg

[Andrea Laforgia]

L'unica differenza è che nel secondo caso ti complichi la vita :-)

[Pleg]

>>Ci sono vantaggi/svantaggi prestazionali nell'usare questa tecnica
>>rispetto
>>all'allocare un array di double monodimensionale di dimensione MxNxP e
>>convertire ogni volta gli indici 3D nella posizione 1D?
>
> L'unica differenza è che nel secondo caso ti complichi la vita :-)

"Non stai pensando quadrimensionalmente" (cit)
:-)

Pleg

[?manu*]

Dal punto di vista delle prestazioni probabilmente sarebbe meglio
allocare un unico blocco:

VANTAGGI:
- hai meno operazioni di allocazione;
- utilizzi meno memoria;
- i dati si trovano in memoria contigua => migliore utilizzo della cache

SVANTAGGI:
- l'accesso casuale agli elementi potrebbe essere più lento. Questo
potrebbe succedere se i valori M e N non sono noti in runtime oppure non
sono potenze di due. Ma questo non si applica alle iterazioni che se
fatte per bene ti costano meno che con l'altro metodo.

E.