|
Nel capitolo precedente ci siamo soffermati ad analizzare una particolare categoria di tipi di dato, gli enumeratori, strumenti capaci
di rappresentare tramite costanti numeriche possibilità, scelte, opzioni, flags e in genere valori che si possano scegliere in un
insieme finito di elementi. Le strutture, invece, appartengono ad un'altra categoria. Anch'esse rappresentano un tipo di dato derivato,
o complesso, poiché non rientra fra i tipi base (di cui ho già parlato) ma è da essi composto. Le strutture ci permettono
di creare nuovi tipi di dato che possano adattarsi in modo migliore alla logica dell'applicazione che si sta scrivendo: in realtà, quello
che permettono di fare è una specie di "collage" di variabili. Ad esempio, ammettiamo di voler scrivere una rubrica, in grado di
memorizzare nome, cognome e numero di telefono dei nostri principali amici e conoscenti. Ovviamente, dato che si tratta di tante persone,
avremo bisogno di array per contenere tutti i dati, ma in che modo li potremmo immagazzinare? Per quello che ho illustrato fino a questo punto,
la soluzione più lampante sarebbe quella di dichiarare tre array, uno per i nomi, uno per i cognomi e uno per i numeri telefonici.
Dim Names() As String
Dim Surnames() As String
Dim PhoneNumbers() As String
Inutile dire che seguendo questo approccio il codice risulterebbe molto confusionario e poco aggiornabile: se si volesse aggiungere, ad esempio,
un altro dato, "data di nascita", si dovrebbe dichiarare un altro array e modificare pressoch? tutte le parti del listato. Usando una struttura,
invece, potremmo creare un nuovo tipo di dato che contenga al suo interno tutti i campi necessari:
Structure Contact
Dim Name, Surname, PhoneNumber As String
End Structure
'...
'Un array di conttati, ognuno rappresentato dalla struttura Contact
Dim Contacts() As Contact
Come si vede dall'esempio, la sintassi usata per dichiarare una struttura è la seguente:
Structure [Nome]
Dim [Campo1] As [Tipo]
Dim [Campo2] As [Tipo]
'...
End Structure
Una volta dichiarata la struttura e una variabile di quel tipo, però, come si fa ad accedere ai campi in essa presenti? Si usa l'operatore
punto ".", posto dopo il nome della variabile:
Module Module1
Structure Contact
Dim Name, Surname, PhoneNumber As String
End Structure
Sub Main()
Dim A As Contact
A.Name = "Mario"
A.Surname = "Rossi"
A.PhoneNumber = "333 33 33 333"
End Sub
End Module
[Ricordate che le dichiarazioni di nuovi tipi di dato (fino ad ora quelli che abbiamo analizzato sono enumeratori e strutture, e le classi solo
come introduzione) possono essere fatte solo a livello di classe o di namespace, e mai dentro ad un metodo.]
Una struttura, volendo ben vedere, non è altro che un agglomerato di più variabili di tipo base e, cosa molto importante, è
un tipo value, quindi si comporta esattamente come Integer, Short, Date, eccetera... e viene memorizzata direttamente sullo stack, senza uso
di puntatori.
Acrobazie con le strutture
Ma ora veniamo al codice vero e proprio. Vogliamo scrivere quella rubrica di cui avevo parlato prima, ecco un inizio:
Module Module1
Structure Contact
Dim Name, Surname, PhoneNumber As String
End Structure
Sub Main()
'Contacts(-1) inizializza un array vuoto,
'ossia con 0 elementi
Dim Contacts(-1) As Contact
Dim Command As Char
Do
Console.Clear()
Console.WriteLine("Rubrica -----")
Console.WriteLine("Selezionare l'azione desiderata:")
Console.WriteLine("N - Nuovo contatto;")
Console.WriteLine("T - Trova contatto;")
Console.WriteLine("E - Esci.")
Command = Char.ToUpper(Console.ReadKey().KeyChar)
Console.Clear()
Select Case Command
Case "N"
'Usa ReDim Preserve per aumentare le dimensioni
'dell'array mentenendo i dati già presenti.
'L'uso di array e di redim, in questo caso, è
'sconsigliato, a favore delle più versatili
'Liste, che però non ho ancora introdotto.
'Ricordate che il valore specificato tra
'parentesi indica l'indice massimo e non
'il numero di elementi.
'Se, all'inizio, Contacts.Length è 0,
'richiamando ReDim Contacts(0), si aumenta
'la lunghezza dell'array a uno, poiché
'in questo caso l'indice massimo è 0,
'ossia quello che indica il primo e
'l'unico elemento
ReDim Preserve Contacts(Contacts.Length)
Dim N As Contact
Console.Write("Nome: ")
N.Name = Console.ReadLine
Console.Write("Cognome: ")
N.Surname = Console.ReadLine
Console.Write("Numero di telefono: ")
N.PhoneNumber = Console.ReadLine
'Inserisce nell'ultima cella dell'array
'l'elemento appena creato
Contacts(Contacts.Length - 1) = N
Case "T"
Dim Part As String
Console.WriteLine("Inserire nome o cognome del " & _
"contatto da trovare:")
Part = Console.ReadLine
For Each C As Contact In Contacts
'Il confronto avviene in modalità
'case-insensitive: sia il nome/cognome
'che la stringa immessa vengono
'ridotti a Lower Case, così da
'ignorare la differenza tra
'minuscole e maiuscole, qualora presente
If (C.Name.ToLower() = Part.ToLower()) Or _
(C.Surname.ToLower() = Part.ToLower()) Then
Console.WriteLine("Nome: " & C.Name)
Console.WriteLine("Cognome: " & C.Surname)
Console.WriteLine("Numero di telefono: " & C.PhoneNumber)
Console.WriteLine()
End If
Next
Case "E"
Exit Do
Case Else
Console.WriteLine("Comando sconosciuto!")
End Select
Console.ReadKey()
Loop
End Sub
End Module
Ora ammettiamo di voler modificare il codice per permettere l'inserimento di più numeri di telefono:
Module Module1
Structure Contact
Dim Name, Surname As String
'Importante: NON è possibile specificare le dimensioni
'di un array dentro la dichiarazione di una struttura.
'Risulta chiaro il motivo se ci si pensa un attimo.
'Noi stiamo dichiarando quali sono i campi della struttura
'e quale è il loro tipo. Quindi specifichiamo che
'PhoneNumbers è un array di stringhe, punto. Se scrivessimo
'esplicitamente le sue dimensioni lo staremmo creando
'fisicamente nella memoria, ma questa è una
'dichiarazione, come detto prima, e non una
'inizializzazione. Vedremo in seguito che questa
'differenza è molto importante per i tipi reference
'(ricordate, infatti, che gli array sono tipi reference).
Dim PhoneNumbers() As String
End Structure
Sub Main()
Dim Contacts(-1) As Contact
Dim Command As Char
Do
Console.Clear()
Console.WriteLine("Rubrica -----")
Console.WriteLine("Selezionare l'azione desiderata:")
Console.WriteLine("N - Nuovo contatto;")
Console.WriteLine("T - Trova contatto;")
Console.WriteLine("E - Esci.")
Command = Char.ToUpper(Console.ReadKey().KeyChar)
Console.Clear()
Select Case Command
Case "N"
ReDim Preserve Contacts(Contacts.Length)
Dim N As Contact
Console.Write("Nome: ")
N.Name = Console.ReadLine
Console.Write("Cognome: ")
N.Surname = Console.ReadLine
'Ricordate che le dimensioni dell'array non
'sono ancora state impostate:
ReDim N.PhoneNumbers(-1)
'Continua a chiedere numeri di telefono finché
'non si introduce più nulla
Do
ReDim Preserve N.PhoneNumbers(N.PhoneNumbers.Length)
Console.Write("Numero di telefono " & N.PhoneNumbers.Length & ": ")
N.PhoneNumbers(N.PhoneNumbers.Length - 1) = Console.ReadLine
Loop Until N.PhoneNumbers(N.PhoneNumbers.Length - 1) = ""
'Ora l'ultimo elemento dell'array è sicuramente
'vuoto, lo si dovrebbe togliere.
Contacts(Contacts.Length - 1) = N
Case "T"
Dim Part As String
Console.WriteLine("Inserire nome o cognome del " & _
"contatto da trovare:")
Part = Console.ReadLine
For Each C As Contact In Contacts
If (C.Name.ToLower() = Part.ToLower()) Or _
(C.Surname.ToLower() = Part.ToLower()) Then
Console.WriteLine("Nome: " & C.Name)
Console.WriteLine("Cognome: " & C.Surname)
Console.WriteLine("Numeri di telefono: ")
For Each N As String In C.PhoneNumbers
Console.WriteLine(" - " & N)
Next
Console.WriteLine()
End If
Next
Case "E"
Exit Do
Case Else
Console.WriteLine("Comando sconosciuto!")
End Select
Console.ReadKey()
Loop
End Sub
End Module
In questi esempi ho cercato di proporre i casi più comuni di struttura, almeno per quanto si è visto fino ad adesso: una struttura
formata da campi di tipo base e una composta dagli stessi campi, con l'aggiunta di un tipo a sua volta derivato, l'array. Fino ad ora, infatti,
ho sempre detto che la struttura permette di raggruppare più membri di tipo base, ma sarebbe riduttivo restringere il suo ambito di
competenza solo a questo. In realtà può contenere variabili di qualsiasi tipo, comprese altre strutture. Ad esempio,
un contatto avrebbe potuto anche contenere l'indirizzo di residenza, il quale avrebbe potuto essere stato rappresentato a sua volta da
un'ulteriore struttura:
Structure Address
Dim State, Town As String
Dim Street, CivicNumber As String
Dim Cap As String
End Structure
Structure Contact
Dim Name, Surname As String
Dim PhoneNumbers() As String
Dim Home As Address
End Structure
Per accedere ai campi di Home si sarebbe utilizzato un ulteriore punto:
Dim A As Contact
A.Name = "Mario"
A.Surname = "Rossi"
ReDim A.PhoneNumbers(0)
A.PhoneNumbers(0) = "124 90 87 111"
A.Home.State = "Italy"
A.Home.Town = "Pavia"
A.Home.Street = "Corso Napoleone"
A.Home.CivicNumber = "96/B"
A.Home.Cap = "27010"
|
|
Feeds
Sondaggio
Condividi
Numeri
