| Corso di Visual Basic: | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| Dodicesima lezione - Nozioni avanzate sulle variabili (a cura di
Giorgio Abraini) Completiamo il discorso sulle variabili e sulla loro dichiarazione: finora abbiamo visto i tipi Byte, Integer, Long, String e Boolean; naturalmente ce ne sono diversi altri, ad eempio: Date, utilizzato per memorizzare le date e le ore, che occupa 8 byte in memoria e che rappresenta una data compresa tra il 1/1/100 e il 31/12/9999; Single, utilizzato per memorizzare valori frazionari a precisione singola (4 byte) compresi tra circa -3,4*10^38 e circa 3,4*10^38; Double, che memorizza valori frazionari a precisione doppia (8 byte) compresi tra circa -1,8*10^308 e circa 1,8*10^308; Currency, che memorizza valori frazionari con quattro decimali (8 byte), solitamente utilizzato per calcoli con valori monetari; Object, che memorizza un riferimento a un oggetto qualunque, come un form, un textbox, un file, ecc. I tipi Single e Double sono gestiti in modo diverso rispetto ai valori interi come Integer e Long: infatti i bit al loro interno sono divisi in due gruppi, la mantissa e l'esponente, secondo la notazione scientifica in base allo standard IEEE; per questo motivo i Single e i Double sono in grado di gestire numeri molto grandi o molto piccoli, ma talvolta hanno difficoltà a trattare le operazioni con numeri interi e con le approssimazioni. Per quanto riguarda il tipo String, finora abbiamo considerato solo le stringhe a lunghezza variabile, ma in realtà ci sono anche le stringhe a lunghezza fissa, che si dichiarano in questo modo:
Mentre una stringa di lunghezza variabile occuperà in memoria 10 byte più il numero di byte necessari per la stringa vera e propria, una stringa di lunghezza fissa occuperà solo il numero di byte indicato nella dichiarazione della variabile: questo perché, se la stringa è di lunghezza variabile, Visual Basic dovrà utilizzare memoria aggiuntiva (10 byte, in questo caso) per conservare informazioni quali, appunto, la lunghezza effettiva della stringa. Esistono poi i dati definiti dall'utente, o meglio dal programmatore, che consistono in un insieme di sottovariabili ciascuna col suo tipo specifico; ad esempio io posso definire un mio tipo di variabile in questo modo:
dove Pippo naturalmente è un nome scelto a caso, e successivamente dichiarare una variabile di questo tipo:
la variabile Topolino occuperà in memoria tanto spazio quanto è necessario per l'insieme dei suoi membri, cioè 2+2+5=9 byte, e si potrà assegnare un valore a ciascuno dei suoi membri scrivendo, ad esempio:
Nella prima lezione avevo detto che la sintassi per la dichiarazione di variabili è la seguente:
In realtà la seconda parte ("As Tipo") si può omettere: in tal caso, per default, la variabile dichiarata sarà di tipo Variant. Questo particolare tipo di dati è in grado di contenere qualunque altro tipo di dati, tranne che quelli definiti dall'utente e le stringhe di lunghezza fissa: in virtù di questa sua caratteristica, il tipo variant ha una grande flessibilità, che consente di utilizzarlo per memorizzare dati che a priori potrebbero assumere diversi tipi. Ad esempio, è possibile fare una cosa del genere:
Se si utilizzassero variabili di tipo definito, bisognerebbe dichiararne tre diverse: una di tipo Double, una di tipo String e una di tipo Integer. La flessibilità del tipo Variant ha ovviamente un rovescio della medaglia: poiché un Variant può assumere valori di vario tipo, VB deve memorizzare, oltre al dato in sé, anche altre informazioni sul tipo di dato; per questo un Variant impegna 16 byte aggiuntivi oltre a quelli necessari per memorizzare il dato, se si tratta di un dato numerico, e ben 22 byte aggiuntivi se il dato contiene caratteri. Non solo, ma poiché non si sa a priori di che tipo è il dato memorizzato in un Variant, ogni volta che questo dato viene utilizzato Visual Basic deve perdere tempo a convertirlo opportunamente nel tipo più appropriato: infatti ogni variabile di tipo Variant assume di volta in volta un sottotipo che indica per l'appunto quale tipo di dati sarebbe più appropriato per il valore assegnato alla variabile Variant. Così, nell'esempio precedente, la variabile V assumerà i sottotipi Double, String e Integer: per rendersene conto è sufficiente utilizzare la funzione
che restituisce una stringa corrispondente al sottotipo della variabile NomeVar; oppure la funzione
che invece restituisce un Integer corrispondente. Da tutto ciò risulta che il tipo Variant deve essere utilizzato solo se è giustificato da un bisogno di flessibilità: se un programmatore sa che una variabile assumerà sempre e soltanto valori compresi, ad esempio tra 1000 e 100000, dovrebbe dichiarare questa variabile come Long, perché così facendo otterrà un vantaggio in termini di utilizzazione della memoria e di velocità di esecuzione. E' vero che se le variabili sono poche questo vantaggio risulta impercettibile, ma se le variabili sono numerose dichiararle come variant è una scelta decisamente inefficiente. E comunque è sempre una buona regola di programmazione assegnare un tipo definito a ogni variabile tutte le volte che è possibile farlo. C'è un modo per evitare che le variabili dichiarate senza tipo assumano di default il tipo variant: bisogna usare l'istruzione DefTipo, la cui sintassi è:
dove tipo indica il tipo di dati definito (ad esempio DefBool, DefInt, DefStr), e intervallocaratteri indica l'intervallo di lettere per le quali sarà impostato il tipo predefinito. Ad esempio, scrivendo, PRIMA di ogni dichiarazione a livello di modulo (e quindi dopo Option Explicit):
Le variabili Arg e X saranno di tipo Long, perché il carattere iniziale del loro nome è compreso negli intervalli specificati nell'istruzione Deftipo, mentre la variabile Pippo sarà un Variant perché la "p" non rientra negli intervalli "a-g" e "x-z". Naturalmente è possibile usare più istruzioni DefTipo, con intervalli diversi, ed è anche possibile ignorare questa istruzione scrivendo esplicitamente il tipo di dato da assegnare a una variabile: la dichiarazione esplicita completa ha sempre la prevalenza rispetto alle impostazioni di default. L'istruzione DefTipo non vale soltanto per le variabili dichiarate, ma anche per i parametri passati come argomenti delle routine e per il tip restituito dalle funzioni. Un modo per abbreviare le dichiarazioni consiste nell'utilizzare i caratteri di dichiarazione del tipo: i tipi principali, infatti, sono identificati da un carattere speciale che può essere posposto al nome della variabile. Ad esempio, le seguenti dichiarazioni sono equivalenti:
perché il carattere % è il carattere di dichiarazione del tipo Integer: notate che il nome della variabile è semplicemente "X", senza il carattere di dichiarazione del tipo. I caratteri di dichiarazione supportati in Visual Basic sono questi: Spesso è necessario convertire un tipo di variabile in un altro: la conversione più frequente è forse quella da numero a stringa e viceversa (cioè da 34 a "34" e viceversa), ma talvolta capita anche di dover convertire un Integer in un Long, o un Single in un Integer, o un Long in Date, ecc. Esistono perciò delle apposite funzioni di conversione del tipo, che iniziano con "c" seguito dall'abbreviazione del tipo restituito:
Naturalmente il parametro passato a queste funzioni deve poter assumere un valore che rientra nell'intervallo specifico del tipo restituito: ad esempio non è possibile scrivere:
perché il valore 100000 è superiore al massimo consentito per un Integer. | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| Archivio: | ||||
| Lezioni | Commenta questa lezione | Invia la tua guida | Avviso
per le nuove lezioni | Proponi
un argomento |
|
Visual Basic Italia©
copyright 2000 - tutti i diritti riservati |