*
 * 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 <stdio.h>	/* 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...
 */