1. Un array è un contenitore di elementi
Probabilmente hai già sentito che i computer possono gestire enormi quantità di informazioni. L'operatore condizionale (if-else) e i cicli (for, while) ovviamente aiutano in questo. Ma non bastano, perché i dati che elaboriamo da qualche parte vanno pur messi.
Per questo in C#, come praticamente in tutti i linguaggi di programmazione, c'è una cosa fighissima chiamata array (Array). A volte li chiamano anche tabelle.
Un array è un oggetto speciale dove puoi conservare non un solo valore, ma più valori.
Se prima abbiamo paragonato una variabile a una scatola (dove puoi mettere un valore), allora un array è più come una scatola divisa in scomparti. Ogni scomparto nella "scatola-array" ha il suo numero. La numerazione, ovviamente, parte da zero...
Oppure, facciamo un altro paragone. Immagina una casa normale e un palazzo a più piani. Una casa normale è abitata da una sola famiglia, mentre il palazzo è diviso in appartamenti. Per spedire una lettera a una famiglia che vive in una casa normale, basta l'indirizzo unico della casa. Ma per una famiglia che vive in un appartamento, serve l'indirizzo della casa e anche il numero dell'appartamento.
Ecco, una variabile-array è come un palazzo a più piani. Puoi conservare non un solo valore, ma diversi. In questa variabile ci sono diversi appartamenti (celle), e puoi accedere a ciascuno tramite il suo numero (indice).
Per farlo, dopo il nome della variabile, tra parentesi quadre, devi indicare l'indice della cella a cui vuoi accedere. È abbastanza semplice:
array[indice] = valore;Dove array è il nome della variabile-array, indice è il numero della cella nell'array, e valore è il valore che vuoi mettere in quella cella.
Ma prima vediamo come si creano gli array.
2. Creazione di un array di elementi in C#
Supponiamo che il tuo programma debba conservare da qualche parte 100 numeri interi. Probabilmente, per questo serve un array. E come si crea?
Se volessimo conservare un solo numero intero, useremmo il tipo int, ma se vogliamo conservare 100 numeri interi, ci serve un array di tipo int. Ecco come sarebbe il codice:
int[] array = new int[100];Vediamo cosa c'è scritto qui.
Come avrai già intuito, a sinistra dell'uguale c'è la dichiarazione della variabile chiamata array di tipo int[]. Dopo il tipo int ci sono le parentesi quadre, che fanno capire che in queste "scatole" puoi mettere più valori.
A destra dell'uguale c'è la "creazione dell'oggetto" (la parola new) di 100 elementi (celle) di tipo int. Niente di troppo complicato.
Se volessimo, per esempio, creare un array di 20 celle per conservare numeri reali, il codice sarebbe così:
double[] vals = new double[20];Il numero di celle in un array si chiama dimensione dell'array o lunghezza dell'array. E proprio perché possono contenere tanti valori, gli array vengono anche chiamati contenitori.
Fatto importante: la dimensione del contenitore array non si può cambiare dopo la creazione.
Puoi crearne uno nuovo, ma la lunghezza di un array già creato non si può cambiare.
3. Lavorare con le celle dell'array
Ok, abbiamo imparato a creare gli array, ma come si lavora con loro?
Praticamente come con le variabili normali, solo che dopo il nome della variabile-array devi sempre specificare il numero della cella con cui lavori.
La numerazione delle celle dell'array parte sempre da zero. Se abbiamo un array di 10 elementi, i numeri (indici) delle sue celle sono 0..9, se l'array ha 200 elementi, allora 0..199. E così via.
Esempi:
int[] a = new int[10]; // Creiamo un array di 10 elementi di tipo int.
a[2] = 4; // Nella cella con indice 2 mettiamo il valore 4.
a[7] = 9; // Nella cella con indice 7 mettiamo il valore 9.
a[9] = a[2] + a[5]; // Nella cella con indice 9 mettiamo la somma dei valori che sono nelle celle 2
// (c'è 4) e 5 (c'è 0).
Ecco cosa ci sarà in memoria dopo aver eseguito questo codice:
La colonna a sinistra dell'array (in grigio) sono i numeri (indici) delle celle. Nelle celle ci sono i valori inseriti: 4, 9 e 4. Subito dopo la creazione, le celle dell'array sono riempite di zeri.
Importante. Tutte le celle di un array hanno lo stesso tipo di dato. Se abbiamo creato un array di stringhe string, nelle sue celle puoi mettere solo stringhe. Il tipo di dato dell'array si imposta quando lo crei. Né il tipo di dato né la lunghezza dell'array si possono cambiare dopo.
4. Array in memoria
Le immagini degli esempi precedenti non sono proprio precise.
Quando crei un array (come anche una stringa), in memoria vengono riservati due blocchi: uno per conservare l'array stesso (il contenitore), e un altro per la variabile che conserva il suo indirizzo. La situazione precisa è mostrata nell'immagine qui sotto:
In verde c'è un array di 10 elementi di tipo int e una variabile di tipo int[] che conserva l'indirizzo (riferimento) dell'array di tipo int in memoria.
Per confronto, in blu c'è una variabile normale di tipo int che conserva il valore 199.
Ricorda un po' come vengono conservate le stringhe in memoria, vero?
Esatto, le stringhe. E come con le stringhe, puoi assegnare "variabili di tipo array" una all'altra:
int[] a = new int[10]; // Creiamo un array di 10 elementi di tipo int.
a[2] = 4; // Nella cella con indice 2 mettiamo il valore 4.
a[7] = 9; // Nella cella con indice 7 mettiamo il valore 9.
int[] b = a; // Nella variabile b salviamo l'indirizzo che c'è in a.
// Ora a e b puntano allo stesso oggetto-array in memoria.
a[9] = b[2] + a[7]; // Nella cella con indice 9 dell'oggetto-array mettiamo la somma dei valori
// che sono nelle celle 2 (c'è 4) e 7 (c'è 9).
L'oggetto-array rimarrà dov'era, e le variabili a e b conserveranno lo stesso indirizzo (riferimento) allo stesso oggetto. Guarda l'immagine:
5. Lavorare con l'array più in dettaglio
Puoi creare un array di qualsiasi tipo. Basta scrivere le parentesi quadre dopo il nome del tipo. La forma generale per creare un array è questa:
tipo[] nome = new tipo[quantità];Dove tipo è il tipo degli elementi (celle) dell'array che conserveremo. Nome è il nome della variabile con cui accederemo all'array, e quantità è il numero di celle nell'array.
Nell'esempio sopra c'è la forma canonica: creazione della variabile-array e creazione dell'oggetto-array. In realtà sono due cose indipendenti. Puoi creare la variabile-array e l'oggetto-array separatamente:
tipo[] nome;
nome = new tipo[quantità];
E un'altra cosa importante
Come indice dell'array e come quantità di elementi dell'array puoi usare variabili e anche espressioni intere.
Esempi:
int n = 100;
int[] a = new int[n]; // Crea un array di n elementi
int n = 100;
int[] a = new int[n * 2 + 3]; // Crea un array di 203 elementi
int n = 100;
int[] a = new int[n];
a[n-1] = 2; // a[99] = 2;
a[n-2] = 3; // a[98] = 3;
a[n/5] = a[n-1] + a[n-2]; // a[20] = a[99] + a[98];
Uscire dai limiti dell'array
Attenzione: se provi ad accedere a una cella dell'array con un indice che non esiste (nel nostro caso sono tutti i numeri interi tranne 0..99), il programma si bloccherà con l'errore IndexOutOfRangeException — indice fuori dai limiti dell'array.
6. Lunghezza dell'array
Come abbiamo visto nell'esempio precedente, puoi creare separatamente una variabile di tipo array e poi assegnarle da qualche parte nel codice un valore (il riferimento all'oggetto-array). Puoi fare anche così:
int[] array; // Crea una variabile-array di tipo int[]
if (a < 10) // Se la variabile a è minore di 10,
array = new int[10]; // allora crea un array di 10 elementi.
else // Altrimenti
array = new int[20]; // crea un array di 20 elementi
E come si lavora con un array così? Come si fa a sapere quanti elementi ci sono?
Per questo l'array ha una proprietà speciale (variabile) — length. E puoi sapere la lunghezza dell'array con questa espressione:
array.Length;Dove array è il nome della variabile-array, e Length è il nome della proprietà dell'oggetto-array. Il valore della proprietà Length non si può cambiare: puoi assegnare il valore di Length ad altre variabili, ma non puoi assegnare nulla a Length (il programma non si compilerà).
Ecco come puoi continuare l'esempio precedente:
int[] array; // Crea una variabile-array di tipo int[]
if (a < 10) // Se la variabile a è minore di 10,
array = new int[10]; // allora crea un array di 10 elementi.
else // Altrimenti
array = new int[20]; // crea un array di 20 elementi
for (int i = 0; i < array.Length; i++) // Ciclo su tutti gli elementi dell'array: da 0 a array.Length — 1
{
Console.WriteLine(array[i]);
}
7. Fatti sugli array in C#
Ricapitoliamo i fatti sugli array:
- Fatto 1. Un array è composto da tante celle.
- Fatto 2. L'accesso a una cella specifica si fa indicando il suo numero.
- Fatto 3. Tutte le celle sono dello stesso tipo.
- Fatto 4. Il valore iniziale di tutte le celle è 0 e null (se nella cella c'è un indirizzo), false (per il tipo bool).
- Fatto 5. string[] list è solo la dichiarazione della variabile: il contenitore (oggetto-array) non è ancora stato creato. Per usarlo, bisogna creare l'array (contenitore) e metterlo in questa variabile, e poi usarlo. Vedi esempio sotto.
- Fatto 6. Quando crei un oggetto-array (contenitore), devi specificare la sua lunghezza — quante celle ha. Si fa con il comando: new TypeName[n];
- Fatto 7. Puoi sapere la lunghezza dell'array tramite la proprietà .Length.
- Fatto 8. Dopo aver creato un array non puoi cambiare né il tipo dei suoi elementi né la loro quantità.
string s; // s è uguale a null
string[] list; // list è uguale a null
list = new string[10]; // La variabile list conserva il riferimento a un oggetto — array di stringhe di 10 elementi.
int n = list.Length; // n è uguale a 10
list = new string[0]; // Ora list contiene un array di 0 elementi.
// L'array c'è, ma non può conservare elementi.
list = null;
Console.WriteLine(list[1]); // Verrà generato un errore — il programma si bloccherà.
// list contiene un riferimento vuoto — null
list = new string[10];
Console.WriteLine(list[10]); // Verrà generato un errore — fuori dai limiti dell'array.
// Se list contiene 10 elementi/celle, gli indici validi sono: 0 1 2 3 4 5 6 7 8 9 — in totale 10.
GO TO FULL VERSION