*
* Ora introdurremo gli Array, detti anche vettori.
* Un array e' un'insieme di elementi dello stesso tipo, cui e' possibile
* accedere tramite un indice, che e' il numero dell'elemento, partendo da
* zero. Per esempio con indice 0 si accede al primo elemento, con indice
* 3 si accede al quarto elemento. Questi elementi possono essere delle
* veriabili INT,FLOAT, o di altro tipo.
* Agli array si da un nome a piacere, col quale identificheremo tutti gli
* elementi (variabili) che lo compongono.
* Gli Array sono fisicamente una serie di variabili messe in fila in
* memoria ad indirizzi adiacenti.
* Iniziamo con gli array ad una dimensione.
* Gli array monodimensionali (o lineari), possono essere visti come i
* gradini di una scala o le pagine di un libro, ossia come una fila di
* elementi tutti uguali. Supponiamo di trovarci in una zona desolata del
* West, nel deserto degli indiani americani. Ad un certo punto troviamo
* i resti di un binario morto delle vecchie ferrovie: perfetto per
* spiegare gli array monodimensionali! Fatto uno spuntino, analiziamo
* quel pezzo di binario: lo possiamo vedere schematicamente come una
* fila di rettangoli tutti uguali. Dato che il treno non ci passa piu'
* posiamo una mela del nostro pranzo nel primo rettangolo. Abbiamo messo
* la mela nel primo elemento dell'array chiamato BINARIO!.
* Mettiamo che quel binario sia composto da 50 rettangoli "interi":
*
* int binario[50];
*
* Abbiamo definito l'array come una serie di 50 variabili intere.
* Ora, se volessimo riprendere la mela, posta nel primo rettangolo, dovremmo
* riferirci a binario[0], mentre se volessimo accedere all'ottavo
* rettangolo, dato che la numerazione dell'indice parte da 0, dovremmo
* scrivere:
*
* binario[7]
*
* Il formato di una dichiarazione di array e' questo:
*
* tipo nome[dimensione];
*
* tipo = tipo di dati di ogni elemento dell'array (int, float...)
* nome = nome che diamo all'array, a piacere
* dimensione = indice: numero degli elementi che compongono l'array.
*
* Attenzione: se l'array dovesse contenere 4 elementi, la dimensione e' 4,
* e gli indici possibili sono 0,1,2,3.
* Da notare che gli indici sono numeri interi non negativi, e vanno da
* 0 a n-1, dove n e' il numero di elementi.
* Basta ricordarsi che l'array parte da 0, anziche' 1, e il gioco e' fatto.
* Facciamo un esempio:
*
* int vett[4]; * Dichiaro un array composto da 4 interi *
*
* vett[0]=3; * Metto nel primo elemento il valore 3 *
* vett[1]=6; * Metto nel secondo elemento il valore 6 *
* vett[2]=2; * Terzo Elem. = 2 *
* vett[3]=9; * Quarto Elem. = 9 *
*
* Abbiamo definito un array con 4 elementi e li abbiamo "riempiti" con
* dei valori. Dato che questi 4 elementi sono variabili di tipo int, gli
* elementi che abbiamo inserito sono dei numeri interi.
* Il numero che mettiamo tra parentesi quadre e' l'indice, ossia il numero
* di elemento dell'array, partendo da 0.
* In un certo senso, un array e' un insieme di n variabili dello stesso
* tipo che condividono lo stesso nome.
* Per riprendere un valore dall'array, si usa la stessa sintassi:
*
* int vett[4]; * Dichiaro un array composto da 4 interi *
*
* vett[0]=3; * Metto nel primo elemento il valore 3 *
* vett[1]=6; * Metto nel secondo elemento il valore 6 *
* vett[2]=2; * Terzo Elem. = 2 *
* vett[3]=9; * Quarto Elem. = 9 *
* pippo = vett[1]; * Pippo varra' 6 *
* printf("Il terzo elemento vale ", vett[3]); * Stampa 9 *
*
* IMPORTANTISSIMO: Il compilatore non verifica il limite di un array, per
* cui e' possibile superarlo senza segnalazioni di errore, trovandoci
* a scrivere per la memoria del computer mandando in coma il sistema.
* Se per esempio definiamo un array con 33 elementi:
*
* AnniGesu[33];
*
* Non appaiono errori di compilazione se scriviamo troppo avanti:
*
* AnniGesu[50]=4;
*
* Ma dove va a finire il 4 che scriviamo? Se AnniGesu[0] si trovava
* all'indirizzo 2000, ad esempio, AnniGesu[32], l'ultimo elemento, si
* sarebbe trovato all'indirizzo di memoria 2032 (ipotizzando che ogni
* elemento sia lungo un solo byte). Quindi scriveremmo all'indirizzo 2050,
* dove poteva anche esserci qualcosa di utile, ed e' pericolosissimo!
* Come mai il C, che e' il linguaggio piu' usato nelle applicazioni serie,
* non controlla queste cose?
* Proprio perche' si suppone che chi lo usa sia uno a cui non servono le
* cinture di sicurezza quando programma. Inoltre, non eseguendo controlli,
* il programma risulta piu' veloce (senza cinture si lavora meglio!).
* NOTA: Il Java controlla la fine degli array, e non permette di scrivere
* fuori dai loro limiti. Questo per evitare problemi di sicurezza.
* Facciamo una prima prova con gli array.
*/
#include <stdio.h> /* Includiamo la libreria standard */
/* Funzione principale e inizio del programma */
int main(void) /* Funzione principale, eseguita per prima */
{ /* Inizio della funzione main() */
int prova[4]; /* Un array con 4 elementi interi, che
* quindi avra' indici da 0 a 3 */
int pippo; /* Definiamo 1 variabile intera */
prova[0]=20; /* Mettiamo un 20 nel primo elemento del
* nostro bravo array */
printf("\nChe velore metto nel secondo elemento? ");
scanf("%d",&pippo);
prova[1]=pippo; /* Copiamo pippo nel secondo elemento...*/
pippo=pippo*2; /* Si puo' scrivere anche pippo *= 2; */
prova[2]=pippo; /* Il terzo elemento vale pippo*2 */
pippo=prova[0]+prova[1];
prova[3]=pippo; /* Il quarto elemento e' uguale al primo
* piu' il secondo */
printf("\nIl primo elemento vale %d\n", prova[0]);
printf("\nIl secondo elemento vale %d\n", prova[1]);
printf("\nIl terzo elemento vale %d\n", prova[2]);
printf("\nIl quarto elemento vale %d\n", prova[3]);
return(0); /* la funzione main restituisce uno 0 intero */
} /* Fine della funzione main() */
/* Abbiamo eseguito un sacco di operazioni inutili e aggrovigliate, che
* pero' in fondo si possono definire utili per scopi didattici.
*/