Newsgroup: it.comp.lang.c
Titolo: Matrice 3D

Ciao,
se io definisco una cosa tipo:
double (*mat)[100][100];
mat=calloc(1,100*100*100*sizeof(double));
ottengo veramente una matrice 100x100x100 di double,
da indirizzare nel solito modo:
for(cont1=0;cont1<100;cont1++)
for(cont2=0;cont2<100;cont2++)
for(cont3=0;cont3<100;cont3++)
mat[cont1][cont2][cont3]=0;
C'è qualcosa di sbagliato in quello che ho scritto?
--
Trust


No, dovrebbe essere tutto a posto.
EMG
--
EMAG Software Homepage:     
http://www.emagsoftware.it
The EMG's ZX-Spectrum Page: 
http://www.emagsoftware.it/spectrum
The Best of Spectrum Games: 
http://www.emagsoftware.it/tbosg

> mat[cont1][cont2][cont3]=0;
Pero' se scegli la seconda soluzione devi cambiare il modo con cui la
indirizzi
for(cont1=0;cont1<100;cont1++)
	for(cont2=0;cont2<100;cont2++)
		for(cont3=0;cont3<100;cont3++)
			mat[cont3 + cont2*100 + cont1 *10000 ]=0;
Ciao
GIGI
-- 
   THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG
visit my home page:
http://web.tiscali.it/KilometroZero

                         mat[cont3 + cont2*100 + cont1 *10000 ]=0;
No, puoi continuare ad utilizzare tranquillamente la normale notazione
con tre indici.



Di questo non ne sono sicuro.
quando  allochi  un  blocco  di  100*100*100  =  1000000  double  non
specifichi che deve essere distrubuito in una struttura cubica di lato
100. Cioe' un cubo con 100 strati  quadrati  di  100  per  100  celle
L'importo di 1000000 potrebbe benissimo essere la rappresentazione di
una struttura
mat1 [50][200][100]
oppure
mat2[50][2][100][100]
Quando fai un indirizzamento  alla cella
mat [1][1][1]
Il compilatore come fa a sapere che deve endare a prendere  la  cella
[1][1] del secondo strato?
Secondo me la rappresentazoine per indici puo' essere ambigua.
BYE


 Di questo non ne sono sicuro.
Se definisci un array in quel modo hai esplicitamente dichiarato la sua
struttura e quindi il compilatore può tranquillamente applicare la
corretta aritmetica degli indici.


corretta aritmetica degli indici.
OK, ma in un mio post prededente ho scritto:
[...]
Pero' se scegli la seconda soluzione devi cambiare il modo con cui la
indirizzi
 
for(cont1=0;cont1<100;cont1++)
         for(cont2=0;cont2<100;cont2++)
                 for(cont3=0;cont3<100;cont3++)
                         mat[cont3 + cont2*100 + cont1 *10000 ]=0;
[...]
Dove  con  seconda  soluzione  intendevo  l'uitlizzo  di  una  malloc


 Dove  con  seconda  soluzione  intendevo  l'uitlizzo  di  una  malloc
Ah. Comunque, anche se definisci la matrice dinamicamente con
double (*mat)[100][100];
anche in questo caso puoi continuare ad utilizzare i tre indici.


anche in questo caso puoi continuare ad utilizzare i tre indici.
Questa e' una matrice di puntatori a variabili di tipo double. Non e'
una matrice di variabili di tipo double. Non puoi usare i tre indici,
perche i tipi sono diversi


 perche i tipi sono diversi
Quello e' un puntatore ad una matrice di double.
double* mat[100][100];
e' una matrice di puntatori a double.
C:\>iao Angelo
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

e' una matrice di puntatori a double.
Ho provato a compilare, penso che tu abbia ragione, pero' nei due casi
puoi utilizzare due indici


 Questa e' una matrice di puntatori a variabili di tipo double.
No, è un puntatore ad array di 100 array di 100 double. Questa
double *mat[100][100];
è invece un array di 100 array di 100 puntatori a double (altrimenti
detta matrice di 100 x 100 puntatori a double). Ma anche in questo caso
puoi utilizzare i tre indici. Eccoti un esempio completo:
#include <stdio.h>
#include <stdlib.h>
int main()
{
    int m1[ 10 ][ 10 ][ 10 ];
    int ( *m2 )[ 10 ][ 10 ];
    int *m3[ 10 ][ 10 ];
    int i, j, k;
    m2 = malloc( 10 * sizeof( int [ 10 ][ 10 ] ) );
    if ( !m2 )
    {
        printf( "Memoria insufficiente per m2\n" );
        exit( 1 );
    }
    for ( i = 0; i < 10; ++i )
        for ( j = 0; j < 10; ++j )
        {
            m3[ i ][ j ] = malloc( 10 * sizeof( int ) );
            if ( !m3[ i ][ j ] )
            {
                printf( "Memoria insufficiente per m3\n" );
                exit( 1 );
            }
        }
    for ( i = 0; i < 10; ++i )
        for ( j = 0; j < 10; ++j )
            for ( k = 0; k < 10; ++k )
            {
                m1[ i ][ j ][ k ] = ( i + 1 ) * ( j + 1 ) * ( k + 1 );
                m2[ i ][ j ][ k ] = ( i + 1 ) * ( j + 1 ) * ( k + 1 );
                m3[ i ][ j ][ k ] = ( i + 1 ) * ( j + 1 ) * ( k + 1 );
            }
    for ( i = 0; i < 10; ++i )
        for ( j = 0; j < 10; ++j )
            for ( k = 0; k < 10; ++k )
            {
                if ( m1[ i ][ j ][ k ] != ( i + 1 ) * ( j + 1 ) * ( k +
1 ) )
                    printf( "Problema in m1\n" );
                if ( m2[ i ][ j ][ k ] != ( i + 1 ) * ( j + 1 ) * ( k +
1 ) )
                    printf( "Problema in m2\n" );
                if ( m3[ i ][ j ][ k ] != ( i + 1 ) * ( j + 1 ) * ( k +
1 ) )
                    printf( "Problema in m3\n" );
            }
     for ( i = 0; i < 10; ++i )
        for ( j = 0; j < 10; ++j )
            free( m3[ i ][ j ] );
    free( m2 );
    return 0;
