*
* Viste le variabili, le stringhe e gli array, possiamo introdurre un nuovo
* tipo di dati, le STRUTTURE, che sono un conglomerato di dati.
* In altri termini, in C una struttura e' un insieme di variabili definito
* da un nome comune. Una struttura e' utile quando dobbiamo gestire un
* gruppo di dati diversi collegati tra loro, ad esempio le varie stringhe
* di testo che compongono un indirizzo: l'array di caratteri che contiene
* il nome, quello che contiene il cognome ecc.
* Nota: in Java non esistono strutture, ma solo classi (ossia oggetti),
* che vedremo nel C++. Comunque, dato che le classi "derivano" dalle
* strutture, e' bene conoscerle, anche se useremo in Java una loro versione
* estesa e object oriented.
* La parola chiave per la dichiarazione di una struttura e' "struct",
* vediamola all'opera:
*
* struct indirizzo {
* char nome[30];
* char via[60];
* char citta[20];
* char stato[2];
* int cap;
* };
*
* Le cose da notare sono 2: la prima e' che all'interno della struttura ci
* possono essere tipi di dati diversi (array char, int, ecc.), la seconda
* e' la sintassi: si mette un nome a piacere dopo "struct", poi si apre
* la parentesi { graffa, si immettono gli elementi terminati ognuno col
* punto e virgola, infine si chiude la parentesi graffa e si mette un punto
* e virgola finale.
* Comunque va notato che questa dichiarazione, in questa forma, non genera
* le variabili, ma la "forma" della struttura chiamata "indirizzo".
* Ossia definiamo un tipo di dati complesso, astrattamente.
* Per creare fisicamente una struttura del tipo descritto, occorre scrivere:
*
* struct indirizzo mioindirizzino;
*
* Soltanto ora abbiamo creato un esemplare della struttura indirizzo, che
* risponde al nome mioindirizzino.
* E' possibile creare subito uno o piu' esemplari di strutture subito, al
* momento della dichiarazione, basta mettere i nomi delle stesse tra la
* parentesi graffa } chiusa e il punto e virgola finale, separandoli con
* delle virgole:
*
* struct indirizzo {
* char nome[30];
* char via[60];
* char citta[20];
* char stato[2];
* int cap;
* } mioindirizzino, indirizzuccio, indirizzucolo;
*
* In questo modo, oltre a dichiarare la forma della struttura indirizzo,
* ne abbiamo creati subito 3 esemplari: mioindirizzino, indirizzuccio e
* indirizzucolo.
* Se si volesse creare una sola struttura, invece, l'indentificatore della
* struttura (in questo caso "indirizzo") sarebbe superfluo:
*
* struct {
* char nome[30];
* char via[60];
* char citta[20];
* char stato[2];
* int cap;
* } indirizzucolo;
*
* Abbiamo cosi' omesso l'identificatore "indirizzo", creando solamente
* l'esemplare unico e irripetibile "indirizzucolo".
* Ora sappiamo come creare strutture... ma come facciamo a leggere e
* scrivere nei suoi elementi?
* Esiste un operatore speciale, l'operatore punto ".", che si mette tra
* il nome della struttura e il nome dell'elemento, ad es:
*
* indirizzucolo.cap = 55100;
*
* Con questa istruzione scrivo nella variabile cap di indirizzucolo il
* valore 55100. Analogamente, con indirizzucolo.via e indirizzucolo.citta
* accedo a via e citta' nella struttura "indirizzucolo", sia in lettura che
* in scrittura. In altri termini, il nome della struttura, seguito da un
* punto e dal nome dell'elemento, e' un riferimento a quel singolo elemento
* della struttura. Visualiziamo il cap:
*
* printf("Il cap e' %d", indirizzucolo.cap);
*
* Allo stesso modo, possiamo scrivere nel nome con gets():
*
* gets(indirizzucolo.nome);
*
* Si puo' anche accedere ai singoli elementi degli array all'interno della
* struttura:
*
* indirizzucolo.nome[0] = "P";
* indirizzucolo.nome[1] = "i";
* indirizzucolo.nome[2] = "p";
* indirizzucolo.nome[3] = "p";
* indirizzucolo.nome[4] = "o";
*
* La notazione e' la consueta, a parte quel "indirizzucolo." iniziale.
* Vediamo ora un utilizzo semplice e compilabile.
*/
#include /* Includiamo la libreria standard */
struct indirizzo { /* Definiamo e creiamo una struttura */
char nome[30];
char via[60];
char citta[20];
};
/* Funzione principale e inizio del programma */
int main(void) /* Funzione principale, eseguita per prima */
{ /* Inizio della funzione main() */
struct indirizzo indirizzucolo; /* Creiamo 1 esemplare della struttura
indirizzo di nome indirizzucolo */
printf("Scrivi il tuo nome: ");
gets(indirizzucolo.nome); /* Mi prendo una stinga con gets */
printf("Scrivi la via: ");
gets(indirizzucolo.via); /* Mi prendo una stinga con gets */
printf("Citta': ");
gets(indirizzucolo.citta); /* Mi prendo una stinga con gets */
/* Stampiamo le stringhe dalla struttura (usare %s nel printf!!) */
printf("\n\nTi chiami %s", indirizzucolo.nome);
printf("\nStai in via %s", indirizzucolo.via);
printf("\nDella meravigliosa citta' di %s", indirizzucolo.citta);
/* Stampiamo un carattere solamente di un array nella struttura */
printf("\n\nE Il nome comincia per %c.\n", indirizzucolo.nome[0]);
/* Stampiamo un messaggio umoristico finale... */
printf("\n\nTi chiederai come ho fatto a saperlo...\n\n");
return(0); /* la funzione main restituisce uno 0 intero */
} /* Fine della funzione main() */
/* Ora vi chiederete: ma non si faceva prima a farsi semplicemente questi
* 3 array e usarli senza doversi fare la struttura? Ebbene si.
* Ma nella prossima lezione vedremo quanto le strutture possano essere
* utili, se riunite in array.
* Notate comunque che in una struttura possiamo inserie anche altre
* strutture, oltre a int, char, float...
*/