*
* Ora tratteremo gli array a 2 dimensioni. Un array a 2 dimensioni si puo'
* considerare un array di array monodimensionali, o in altri termini una
* matrice righe-colonne, molto simile ad una scacchiera o al reticolo
* della battaglia navale. La tabellina pitagorica puo' essere considerata
* un'array, ad esempio.
* Ecco come si definisce un array a 2 dimensioni:
*
* tipo nome[dimensione1] [dimensione2];
*
* Come esempio, definiamo un array con 3 righe e 5 colonne, ossia 3*5=15
* elementi:
*
* int tabelluccia[3][5];
*
* In questo modo creeremo una tabella del genere:
*
* [0][0] [0][1] [0][2] [0][3] [0][4]
*
* [1][0] [1][1] [1][2] [1][3] [1][4]
*
* [2][0] [2][1] [2][2] [2][3] [2][4]
*
* Con [0][0] si intende il primo elemento, e per raggiungere gli altri si
* devono variare i 2 indici opportunamente.
* Per scrivere un valore nell'elemento [1][2], si fa cosi':
*
* tabelluccia[1][2]=10; * Scrivo nell'elemento [1][2] *
*
* Il primo indice e' quello che corrisponde alle righe, mentre il secondo
* corrisponde alle colonne.
* Definiamo un array come quello sopra, con 3 righe e 5 colonne:
*
* int battaglia[3][5];
*
* Ora potremo giocare a battaglia navale nell'array: mettiamo un 1 dove
* stanno le navi...
*
* battaglia[1][3] = 1;
* battaglia[1][4] = 1;
*
* Abbiamo messo un incrociatore nel nostro mare. Ora giochiamo:
*
* battaglia[2][0] -> niente
* battaglia[1][4] -> colpito!
*
* Nella battaglia navale si usano i numeri e le lettere, ad esempio 1A,1B
* eccetera, per maggiore chiarezza, ma nel nostro caso entrambi gli indici
* sono numerici. Abbiamo detto che la tabellina pitagorica e' un array
* bidimensionale: ci proporremo di fare un programma che stampa una
* tavola pitagorica.
* Nel corso di questo programma vedremo dei loop for nidificati; un loop
* e' nidificato quando si trova all'interno di un altro ciclo, ad es:
*
* for (i=0; i<10; i++) * Loop esterno per fare tutte le righe *
* {
* for (j=0; j<10; j++) tabba[i][j]=5; * Loop interno che fa una riga *
* }
*
* Questi 2 loop nidificati riempiono l'array tabba con valori 5.
* Dato che gli array bidimensionali hanno 2 dimensioni, un solo loop
* for non basta per riempirli, perche' in un array di dimensioni [10][10]
* ci sono 100 elementi, e per riempirli tutti e' necessario scrivere in
* tutte le conbinazioni di indici: i due loop nidificati qua sopra quando
* riempiono l'array seguono questo ordine:
*
* Il loop for interno, la prima volta che e' eseguito, ha i che vale 0
* e j varia da 0 a 9:
*
* [0][0] [0][1] [0][2] [0][3] [0][4] [0][5] [0][6] [0][7] [0][8] [0][9]
*
* La seconda volta che e' eseguito, i vale 1:
*
* [1][0] [1][1] [1][2] [1][3] [1][4] [1][5] [1][6] [1][7] [1][8] [1][9]
*
* E cosi' via, finche' il loop esterno non termina con i=9.
* Un'ultima nota: per inizializzare un array bidimensionale, ossia dare
* subito un valore ai suoi elementi al momento della dichiarazione, si
* fa come con gli array monodimensionali, ma per maggior chiarezza si
* adotta una diversa forma "estetica":
*
* int prova[4][2] = {
* 4,5
* 8,3
* 2,2
* 9,1 };
*
* In questo modo si rende piu' chiara la posizione di righe e colonne, ma
* si potrebbe dichiarare anche in modo meno leggibile.
* Vediamo il programmino:
*/
#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 i,j; /* Due variabili intere che mi servono come
* contatori per righe e colonne dell'array */
int tabba[10][10]; /* Tabella di 10*10=100 elementi */
/* Con questi 2 loop nidificati creiamo la tabella pitagorica, ossia
* diamo come valore di ogni elemento dell'array la moltiplicazione del
* suo indice i per l'indice j, ossia il risultato di riga*colonna, infatti
* nella tabella pitagorica all'incrocio di righe e colonne si trova proprio
* il risultato della moltiplicazione di riga*colonna.
* Occorrono 2 loop nidificati perche' con il loop interno si fa una riga,
* il quale e' ripetuto per il numero delle righe i, in modo da farle tutte.
*/
for (i=0; i<10; i++) /* Loop esterno... numero righe: 10 */
{
for (j=0; j<10; j++) tabba[i][j]=i*j; /* Facciamo la moltiplicazione
* i*j per tutta la riga col
* loop for nidificato. */
}
/* Ora con altri 2 loop for nidificati stampiamo tutti i valori della
* tabella a video nell'ordine giusto, lo stesso della scrittura.
* Da notare che saltiamo gli indici 0, che essendo sempre zero non ci
* interessano. */
for (i=1; i<10; i++) /* Loop esterno per fare tutte le righe*/
{
for (j=1; j<10; j++) /* Loop interno che stampa una riga */
{
printf("%3d",tabba[i][j]); /* Stampiamo un valore */
}
printf("\n"); /* a capo ad ogni incremento di i */
}
return(0); /* la funzione main restituisce uno 0 intero */
} /* Fine della funzione main() */
/* Avrete notato che nel printf, al posto del solito %d, c'e' un %3d.
* Infatti e' possibile indicare, in questo modo, che vogliamo stampare
* sempre e solo 3 caratteri per ogni numero; questo per "pareggiare" la
* tabella, che altrimenti con il solo %d non sarebbe stata allineata
* per la differente lunghezza dei numeri ad una cifra (0-9) rispetto a
* quelli con due cifre (10-81). Per esempio con %5d si sarebbero stampati
* 5 caratteri per ogni numero, anche se fosse ad 1 solo carattere: i
* restanti 4 sarebbero spaziature. Questa opzione e' presente anche per
* i %f, adatti ai numeri float.
*
* E' possibile lavorare con array a 3 o piu' dimensioni:
*
* int prova[4][4][4]
*
* Questo e' un vettore a 3 dimensioni: avra' 4*4*4=64 elementi.
* Comunque per ora ci bastano array ad 1 e 2 dimensioni.
*/