Array a una dimensione

Fino a questo momento abbiamo avuto a che fare con variabili "singole". Con questo voglio dire che ogni identificatore dichiarato puntava ad una cella di memoria dove era contenuto un solo valore, leggibile e modificabile usando il nome specificato nella dichiarazione della variabile. L'esempio classico che si fa in questo contesto è quello della scatola, dove una variabile viene, appunto, assimilata ad una scatola, il cui contenuto può essere preso, modificato e reimmesso senza problemi.


Allo stesso modo, un array è un insieme di scatole, tutte una vicina all'altra (tanto nell'esempio quando nella posizione fisica all'interno della memoria), a formare un'unica fila che per comodità si indica con un solo nome. Per distinguere ogni "scomparto" si fa uso di un numero intero (che per convenzione è un intero a 32 bit, ossia Integer), detto indice. Tutti i linguaggi .NET utilizzano sempre un indice a base 0: ciò significa che si inizia a contare da 0 anziché da 1:


La sintassi usata per dichiarare un array è simile a quella usata per dichiarare una singola variabile:

Dim [nome]([numero elementi - 1]) As [tipo] 

La differenza tra le due risiede nelle parentesi tonde che vengono poste dopo il nome della variabile. Tra queste parentesi può anche essere specificato un numero (sempre intero, ovviamente) che indica l'indice massimo a cui si può arrivare: dato che, come abbiamo visto, gli indici sono sempre a base 0, il numero effettivo di elementi presenti nella collezione sarà di un'unità superiore rispetto all'indice massimo. Ad esempio, con questo codice:

Dim A(5) As String 

il programmatore indica al programma che la variabile A è un array contenente questi elementi:

A(0), A(1), A(2), A(3), A(4), A(5) 

che sono per la precisione 6 elementi. Ecco un listato che esemplifica i concetti fin'ora chiariti:

Module Module1
    Sub Main()
        'Array che contiene 10 valori decimali, rappresentanti voti
        Dim Marks(9) As Single
        'Questa variabile terrà traccia di quanti voti
        'l'utente avrà immesso da tastiera e permetterà di
        'calcolarne una media
        Dim Index As Int32 = 0

        'Mark conterrà il valore temporaneo immesso 
        'da tastiera dall'utente
        Dim Mark As Single
        Console.WriteLine("Inserisci un altro voto (0 per terminare):")
        Mark = Console.ReadLine
        
        'Il ciclo finisce quando l'utente immette 0 oppure quando
        'si è raggiunto l'indice massimo che è
        'possibile usare per identificare una cella dell'array
        Do While (Mark > 0) And (Index < 10)
            'Se il voto immesso è maggiore di 0, lo memorizza
            'nell'array e incrementa l'indice di 1, così da
            'poter immagazzinare correttamente il prossimo voto nell'array
            Marks(Index) = Mark
            Index += 1
            
            Console.WriteLine("Inserisci un altro voto (0 per terminare):")
            Mark = Console.ReadLine
        Loop
        'Decrementa l'indice di 1, poiché anche se l'utente
        'ha immesso 0, nel ciclo precedente, l'indice era stato
        'incrementato prevedendo un'ulteriore immissione, che,
        'invece, non c'è stata
        Index -= 1

        'Totale dei voti
        Dim Total As Single = 0
        'Usa un ciclo For per scorrere tutte le celle dell'array
        'e sommarne i valori
        For I As Int32 = 0 To Index
            Total += Marks(I)
        Next

        'Mostra la media
        Console.WriteLine("La tua media &egrave: " & (Total / (Index + 1)))
        Console.ReadKey()
    End Sub
End Module 

Il codice potrebbe non apparire subito chiaro a prima vista, ma attraverso uno sguardo più attento, tutto si farà più limpido. Di seguito è scritto il flusso di elaborazione del programma ammettendo che l'utente immetta due voti:

• Richiede un voto da tastiera: l'utente immette 5 (Mark = 5)
• Mark è maggiore di 0
  • Inserisce il voto nell'array: Marks(Index) = Marks(0) = 5
  • Incrementa Index di 1: Index = 1
• Entrambe le condizioni non sono verificate: Mark <> 0 e Index < 9. Il ciclo continua
• Richiede un voto da tastiera: l'utente immette 10 (Mark = 10)
• Mark è maggiore di 0
  • Inserisce il voto nell'array: Marks(Index) = Marks(1) = 10
  • Incrementa Index di 1: Index = 2
• Entrambe le condizioni non sono verificate: Mark <> 0 e Index < 9. Il ciclo continua
• Richiede un voto da tastiera: l'utente immette 0 (Mark = 0)
• Mark è uguale a 0: il codice dentro if non viene eseguito
• Una delle condizioni di arresto è verificata: Mark = 0. Il ciclo termina
• Decrementa Index di 1: Index = 1
• Somma tutti i valori in Marks da 0 a Index (=1): Total = Marks(0) + Marks(1) = 5 + 10
• Visualizza la media: Total / (Index + 1) = 15 / (1 + 1) = 25 / 2 = 7.5
• Attende la pressione di un tasto per uscire

È anche possibile dichiarare ed inizializzare (ossia riempire) un array in una sola riga di codice. La sintassi usata è la seguente:

Dim [nome]() As [tipo] = {elementi dell'array separati da virgole} 

Ad esempio:

Dim Parole() As String = {"ciao", "mouse", "penna"} 

Questa sintassi breve equivale a questo codice:

Dim Parole(2) As String
Parole(0) = "ciao"
Parole(1) = "mouse"
Parole(2) = "penna" 

Un'ulteriore sintassi usata per dichiarare un array è la seguente:

Dim [nome] As [tipo]() 

Quest'ultima, come vedremo, sarà particolarmente utile nel gestire il tipo restituito da una funzione.

Array a più dimensioni

Gli array a una dimensione sono contraddistinti da un singolo indice: se volessimo paragonarli ad un ente geometrico, sarebbero assimilabili ad una retta, estesa in una sola dimensione, in cui ogni punto rappresenta una cella dell'array. Gli array a più dimensioni, invece, sono contraddistinti da più di un indice: il numero di indici che identifica univocamente un elemento dell'array di dice rango. Un array di rango 2 (a 2 dimensioni) potrà, quindi, essere paragonato a un piano, o ad una griglia di scatole estesa in lunghezza e in larghezza. La sintassi usata è:

Dim [nome]( , ) As [tipo] 'array di rango 2
Dim [nome]( , , ) As [tipo] 'array di rango 3 

Ecco un esempio che considera un array di rango 2 come una matrice quadrata:

Module Module1
    Sub Main()
        'Dichiara e inizializza un array di rango 2. Dato che
        'in questo caso abbiamo due dimensioni, e non una sola,
        'non si può specificare una semplice lista di
        'valori, ma una specie di "tabella" a due entrate.
        'Nell'esempio che segue, ho creato una semplice
        'tabella a due righe e due colonne, in cui ogni cella
        'è 0.
        Dim M(,) As Single = _
            {{0, 0}, _
            {0, 0}}
        'Bisogna notare il particolare uso delle graffe: si 
        'considera l'array di rango 2 come un array i cui
        'elementi sono altri array

        Console.WriteLine("Inserire gli elementi della matrice:")
        For I As Int32 = 0 To 1
            For J As Int32 = 0 To 1
                Console.Write("Inserire l'elemento (" & I & ", " & J & "): ")
                M(I, J) = Console.ReadLine
            Next
        Next

        Dim Det As Single
        Det = M(0, 0) * M(1, 1) - M(0, 1) * M(1, 0)
        Console.WriteLine("Il determinante della matrice &egrave: " & Det)

        Console.ReadKey()
    End Sub
End Module 

Rappresentando graficamente l'array M, potremmo disegnarlo così:


Ma il computer lo può anche vedere in questo modo, come un array di array:


Come si vede dal codice di inizializzazione, seppur concettualmente diversi, i due modi di vedere un array sono compatibili. Tuttavia, bisogna chiarire che solo e soltanto in questo caso, le due visioni sono conciliabili, poiché un array di rango 2 e un array di array sono, dopo tutto, due entità ben distinte. Infatti, esiste un modo per dichiarare array di array, come segue:

Dim [nome]()() As [tipo] 'array di array 

E se si prova a fare una cosa del genere:

Dim A(,) As Int32
Dim B()() As Int32
'...
A = B 

Si riceve un errore esplicito da parte del compilatore.

Ridimensionare un array

Può capitare di dover modificare la lunghezza di un array rispetto alla dichiarazione iniziale. Per fare questo, si usa la parola riservata ReDim, da non confondere con la keyword Dim: hanno due funzioni totalmente differenti. Quando si ridimensiona un array, tutto il suo contenuto viene cancellato: per evitare questo inconveniente, si deve usare l'istruzione ReDim Preserve, che tuttavia ha prestazioni molto scarse a causa dell'eccessiva lentezza. Entrambe le istruzioni derivano dal Visual Basic classico e non fanno parte, pertanto, della sintassi .NET, sebbene continuino ad essere molto usate, sia per comodità, sia per abitudine. Il metodo più corretto da adottare consiste nell'usare la procedura Array.Resize. Eccone un esempio:

Module Module1
    Sub Main()
        Dim A() As Int32
        Dim n As Int32

        Console.WriteLine("Inserisci un numero")
        n = Console.ReadLine

        'Reimposta la lunghezza di a ad n elementi
        Array.Resize(A, n)

        'Calcola e memorizza i primi n numeri pari (zero compreso)
        For I As Int16 = 0 To n - 1
            A(I) = I * 2
        Next

        Console.ReadKey()
    End Sub
End Module 

La riga Array.Resize(A, n) equivale, usando ReDim a:

ReDim A(n - 1) 

Per ridimensionare un array a più dimensioni, la faccenda si fa abbastanza complessa. Per prima cosa, non si può utilizzare Array.Resize a meno che non si utilizzi un array di array, ma anche in quel caso le cose non sono semplici. Infatti, è possibile stabilire la lunghezza di una sola dimensione alla volta. Ad esempio, avendo un array M di rango 2 con nove elementi, raggruppati in 3 righe e 3 colonne, non si può semplicemente scrivere:

ReDim M(2, 2) 

perchè, così facendo, solo la riga 2 verrà ridimensionata a 3 elementi, mentre la 0 e la 1 saranno vuote. Il codice da usare, quindi, è:

ReDim M(0, 2)
ReDim M(1, 2)
ReDim M(2, 2) 

In questo modo, ogni "riga" viene aggiustata alla lunghezza giusta.