Le Variabili

Una Variabile è una grandezza che può assumere valori diversi, eventualmente entro un certo intervallo di tempo.

In informatica una Variabile è un contenitore che serve a memorizzare un valore su cui il programma deve eseguire delle operazioni. Più precisamente, una variabile è un nome che punta ad una locazione di memoria in cui vengono memorizzate le informazioni.

Senza variabili, un programma non può eseguire nessuna operazione utile in quanto non ha modo di poter memorizzare i dati passati dall'utente né i risultati delle proprie operazioni.
Quando si programma è quindi utile, ed indispensabile, avere delle variabili su cui poter lavorare anche solo per semplici somme o sottrazioni. Ancor più utile è conoscere i tipi di variabili , con i quali si ha a che fare, per evitare di imbattersi in errori dovuti ad una non corrispondenza dei tipi fra i dati da immagazzinare ed il tipo di dati che una variabile può contenere.

Dichiarazione di variabili

Gambas è un linguaggio di programmazione tipizzato staticamente ^{[Nota 1]}, il che significa che le variabili ed il tipo di dati che conterranno devono essere dichiarate ^{[Nota 2]} prima del loro uso (tipizzato) e che il tipo di dati non varierà per il resto dell'esecuzione del programma (staticamente). Se, ad esempio, alla variabile A dichiarata di tipo Integer venisse ad un certo punto assegnato un valore di tipo stringa, Gambas segnalerebbe un errore in fase di esecuzione di tipo non corrispondente; un altro errore verrebbe segnalato se cercassimo di assegnare un valore ad una variabile non dichiarata.

Una variabile è individuata, e distinta rispetto alle altre eventuali esistenti, attraverso un proprio nome chiamato Identificatore ^{[Nota 3]}, che rappresenta anche il simbolo della variabile utilizzabile nel codice del programma.

Ricapitolando, una variabile è un dato definito da tre attributi:

• un identificatore, ossia il nome della variabile definito dal programmatore;
• un indirizzo di memoria, ove ha inizio il valore o l'insieme di valori memorizzati che costituisce il dato salvato;
• un tipo che definisce la quantità di memoria occupata, utilizzata per memorizzare il dato nella variabile.

Variabili globali e variabili locali

La dichiarazione delle variabili può essere:

• Locale: ha effetto solo nella routine (Sub, Function o Procedure), in cui sono definite ^{[Nota 4]}; più precisamente dalla riga in cui la dichiarazione è stata effettuata fino alla fine (End) della routine.
• Globale: ha effetto in tutta la Classe o in tutto il Modulo, ossia in tutte le routine contenute nella stessa Classe o nello stesso Modulo, ove è stata posta la dichiarazione.

Dichiarazione delle variabili Locali

Per le variabili locali la dichiarazione avviene secondo la seguente sintassi, da inserire all'interno della funzione o procedura:

 DIM Variabile AS [NEW] tipo_di_dato [=valore_predefinito]

L'istruzione DIM, utilizzata in una Sub o Function o Procedure, può essere dichiarata in un qualunque punto della sub-routine, non necessariamente all'inizio della sub-routine medesima, ma in tal caso la sua visibilità (scope) sarà efficace soltanto dalla riga successiva sottostante a quella della dichiarazione della variabile. Pertanto il simbolo locale (identificatore) della variabile può essere utilizzato all'interno della predetta sub-routine, ma solo dopo la sua dichiarazione.
L'istruzione DIM, inoltre, può riferirsi contemporaneamente, su un'unica medesima riga, a più variabili (l'identificatore di ciascuna andrà separato da quello delle altre, presenti sulla medesima riga, mediante una virgola):

DIM Variabile_1, Variabile_2, Variabile_3 As tipo_di_dato

ed anche a variabili appartenenti a tipi di dati differenti:

DIM Variabile_1 As Byte, Variabile_2 As Integer = "100000", Variabile_3 As String = "qualsiasi testo"

L'uso della parola-chiave DIM non produce ancora nulla in memoria, ma dice solo al compilatore che quel nome di variabile verrà utilizzato per puntare ad un particolare tipo di dato.
Una volta stabilito il tipo, la variabile deve essere istanziata, ovvero creata realmente in memoria.
Questo dipendentemente dal tipo di variabile: se è un Oggetto si usa la sintassi NEW, mentre per le variabili normali l'assunzione in memoria avviene alla prima assegnazione o al primo utilizzo.

Dichiarazione delle variabili Globali

Per le variabili globali la dichiarazione avviene secondo la seguente sintassi, che va inserita all'inizio del codice della classe o del modulo:

 [STATIC](PUBLIC|PRIVATE) Variabile [Array] AS [NEW] tipo_di_dato

Variabili Pubbliche e variabili Private

Si noti che è possibile dichiarare variabili globali che sono o pubbliche (PUBLIC) o private (PRIVATE). Se si specifica la parola chiave PUBLIC allora la variabile sarà accessibile anche da altre classi mentre per ciò che riguarda PRIVATE, la variabile sarà accessibile solo alla classe in cui è dichiarata.

Rendere indistruttibile una variabile con STATIC

Se si desidera che una variabile globale pubblica non venga azzerata, anche se appartenente ad una Classe, è necessario anteporre la parola STATIC. In questo caso, la variabile viene impostata alla prima chiamata, e rimane valida fino al termine del programma. Quindi, la variabile, preceduta dal prefisso STATIC, viene definita come indistruttibile, nel senso che vivrà fino a che non viene terminato il programma. Una volta inizializzata ^{[Nota 5]}, la variabile vive a prescindere dalla Classe, o il Modulo, che la contiene; e può essere analizzata in qualsiasi momento. Eventuali modifiche del suo valore vengono conservate tali fino al termine dell'applicazione. ^{[Nota 6]}

NEW

La parola chiave NEW indica all'interprete che stiamo dichiarando nuovi oggetti oppure matrici di tipo dinamico.

Esempio 1:

 DIM hFile AS NEW File

Dichiara hFile come una nuova istanza ^{[Nota 7]} dell'oggetto File, creandolo fisicamente in memoria.

Esempio 2:

 DIM Matrice AS NEW Integer[]

Dichiara Matrice come una nuova matrice dinamica di tipo Integer. Le matrici di tipo dinamico possono crescere di dimensioni durante l'esecuzione del programma e non necessitano pertanto di essere dimensionate in fase di dichiarazione.

Tipi di variabili

Dopo aver dato uno sguardo alla dichiarazione, passiamo ad analizzare quali "tipi" di variabili (corrispondenti in vero ai tipi di dati) si hanno a disposizione per i propri programmi.

Tipo variabile	Descrizione Valori che il tipo può rappresentare	Valore di default	Memoria occupata
Boolean	Può assumere solo i due valori logici TRUE (Vero) e FALSE (falso)	FALSE	1 byte
Byte	Assume valori da 0 a 255	0	1 byte
Short	Assume valori compresi tra -32768 e +32767	0	2 byte
Integer	Assume valori compresi tra -2147483648 e +2147483647	0	4 byte
Single	Assume valori compresi tra -1,7014118-37 e +1,7014118E+38 Cifre significative: 6	0.0	4 byte
Float	Assume valori compresi tra -8,98846567431105E-307 e +8,98846567431105E+308 Cifre significative: 15	0.0	8 byte
Long	Assume valori compresi tra -9.223.372.036.854.775.808 e +9.223.372.036.854.775.807	0	8 byte
Date	Variabile per la gestione delle date ed orari	NULL	8 byte
String	Può contenere qualunque tipo di carattere alfanumerico (lettere e numeri, simboli vari) per la gestione stringhe di caratteri	NULL	4 byte su sistemi a 32 bit; 8 byte su sistemi a 64 bit [Nota 8]
Variant	Variabile utile quando non si conoscono i tipi di dati con cui si deve lavorare. Può assumere tutti i tipi di variabile	NULL	12 byte su sistemi a 32 bit; 16 byte su sistemi a 64 bit
Object	Riferimento indiretto e generico ad un Oggetto	NULL	4 byte su sistemi a 32 bit; 8 byte su sistemi a 64 bit
Pointer	Riferimento ad un indirizzo di memoria	0	4 byte su sistemi a 32 bit; 8 byte su sistemi a 64 bit

Ad ogni modo, bisogna ricordare che nella programmazione ad oggetti, come è Gambas, tutto è un Oggetto.
Quindi, non bisogna considerare le dimensioni del dato puro, ma anche della struttura che lo gestisce ^{[Nota 9]}, appunto la Classe.
Questa può essere definita con Proprietà (variabili) e Metodi (funzioni), le cui dimensioni hanno una forma che dipende da come è stata costruita a livello inferiore.

Altra tipologia di suddivisione delle variabili

Le variabili possono suddividersi anche in base ad un'altra tipologia distinguendole in tre categorie:

• variabili semplici (come ad esempio le variabili viste nella tabella precedente);
• variabili di tipo aggregato (come i Vettori);
• variabili di tipo composito (come le Strutture).

Assegnare un valore ad una variabile

Assegnare un valore ad una variabile è tra le cose più ricorrenti nella stesura di un codice. La cosa è molto semplice e segue questa sintassi:

 nome_variabile = valore_variabile

dove nome_variabile è la nostra variabile dichiarata e valore_variabile un opportuno valore alfanumerico che sia dello stesso tipo per cui la variabile è stata dichiarata.

Note

[1] La "Tipizzazione " è l'attribuzione dei tipi di dati alle variabili (esempio: Dim variabile As Integer). La tipizzazione si distingue in: Tipizzazione Statica e Tipizzazione Dinamica.

[2] "Dichiarare " o anche "Dimensionare " una variabile significa specificare il tipo di dato della variabile.

[3] Sull'uso degli Identificatori delle variabili vedere anche questa pagina della Wiki: Usare come identificatore di variabile il nome di una parola chiave o di una funzione ovvero un carattere non consentito

[4] Una variabile automatica locale viene creata sullo stack frame; pertanto il suo contenuto viene irrimediabilmente perduto e sovrascritto all'uscita della routine ove è stata dichiarata. Poiché, dunque, essa viene distrutta alla fine dello scope, la variabile locale per essere distrutta e liberare così memoria non ha bisogno di un Distruttore né di un proprio Metodo ".Delete".

[5] "Inizializzare " significa effettuare la prima assegnazione di un valore ad una variabile.

[6] Si veda al riguardo il paragrafo: Persistenza di una Classe e persistenza di un simbolo di un Oggetto verso altri Oggetti dichiarati della medesima Classe: "Statico" e "Dinamico"

[7] "Istanziare " significa creare un Oggetto di una Classe.

[8] Una stringa, formata da qualsiasi quantità di caratteri, occupa *sempre* 4 byte (nei sistemi a 32 bit) o 8 byte (nei sistemi a 64 bit); questo perché una stringa è in realtà un puntatore a una struttura più complessa che contiene, fra l'altro, la lunghezza della stringa.

[9] Si veda al riguardo il file header dei sorgenti di Gambas: /....../main/share/gambas.h