Newsgroup: it.comp.lang.c++
Titolo: aiuto dichiarazione variabili

Ho dei seri dubbi su come si debbano dichiarare degli array di strutture e
degli array di puntatori a strutture. Mi aiutate, please?
Ovviamente in C++ :-)
San Vegeta from Hell
P.S. Per fare riferimento ad una variabile di una struct, tramite puntatore,
come si fa?
struct prova {
            int a;
            double b;
        };
struct *punt_prova = &prova ??????
e per riferirsi a b?

 e per riferirsi a b?
Quello che a me rende un po' piu` facile la vita e`
riuscire a considerare che
struct prova e
struct prova *
sono dei tipi, cosi` come int, float, double, ecc.
(anche con le opportune distinzioni)
struct prova {
            int a;
            double b;
        };
struct prova prova; // dichiara e definisce la variabile prova di tipo struct
prova;
struct prova *punt_prova=&prova; // dichiara e definisce la variabile
                                                                 // punt_prova
di tipo
                                                                 //  puntatore
a struct prova
                                                                 // e
inizializza tale variabile (punt_prova)
                                                                // con
l'indirizzo della variabile prova;
a me aiuta notare l'analogia sintattica tra
int prova e
struct prova *prova; //anche se l'* e` attaccato a prova, esso e` parte del
tipo.
double c = punt_prova->b;  // dichiara e definisce la variabile c di tipo
double
                                                    // inizializzandola con il
contenuto della variabile
                                                    //prova.b (punt_prova punta
a prova che e` una istanza
                                                   //di una struttura. Da
questa istanza si prende il contenuto
                                                   //del campo b e lo si
assegna a )
la precedente inizializzazione poteva essere scritta anche
double c = (*punt_prova).b; //forse le parentesi sono inutili ma sinceramente
non lo
                                                   //so. Dipende dalla
priorita` relativa degli operatori
                                                   // * (asterisco) e .
(punto).
L'equivalenza con la precedente si deduce
in quanto (*punt_prova)  indica cio` che e` puntato da punt_prova
(cioe` la variabile prova);
per gli array:
struct prova arrayDiStrutture[15]; //dichiara e definisce un array
                                                               //di 15 elementi
dove
                                                               //ciascun
elemento puo` essere visto
                                                               //come una
variabile di
                                                               //tipo struct
prova
arrayDiStrutture[3].b=14.8;
arrayDiStrutture[3] lo vedo come una variabille di tipo prova.
A tale variabile assegno, nel campo b, il valore 14.8.
Qui le parentesi tonde non servono ma credo che si potrebbe anche scrivere
(arrayDiStrutture[3]).b=14.8;
struct prova *arrayDiPuntatori[10]; //dichiara e definisce un array di
                                                                  //10 elementi
dove ciascun elemento
                                                                  //puo` essere
visto come una variabile
                                                                  //di tipo
puntatore a struct prova.
ad esempio
arrayDiPuntatori[0] = &prova;
arrayDiPuntatori[0]->b=0.0;
arrayDiPuntatori[0] lo vedo come una variabile di tipo "puntatore a struct
prova".
NB.
E` un errore arraydiPuntatori[0]->b=0.0
senza prima aver
fatto un assegnamento del tipo
arrayDiPuntatori[0] = &prova;
oppure aver eseguito una new (se la si esegue, ricordarsi che da
qualche parte dovra` esserci la corrispondente delete)
ad esempio:
arrayDiPuntator[0] = new struct prova;
.....
delete arrayDiPuntatori
Spero di non aver detto troppe scemenze, ma visto che non
ho verificato assolutamente niente di quello che ho scritto
(non ho tempo di farlo perche' ultimamente mi tocca persino lavorare :-) ,
prendilo con la dovuta cautela.
Marco Guidi

 delete arrayDiPuntatori
Qui era
delete arrayDiPuntatory[0];
Marco Guidi

come si fa?
test Data;
Data.b = 1.0;
Data.c = "Una stringa";
int* val = &Data.a;
test array[20];
array[2].a = 10;
test* Ptr = new test;
Ptr->b = 2.3;
Paolo
-----------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
-----------------------------------------------

 wrote in message
380C3E75...@sssup.it...


 int* val = &Data.a;
Perchč il puntatore non va deferenziato? cioč, non dovrebbe essere
*Data.b=1.0; ?
grazie per l'aiuto, meno male che ho smesso di seguire il vekkio testo č ho
cominciato da capo il Lippmann-Lajoie...
San Vegeta