Variabile (informatica)

Una variabile, in informatica, è un contenitore di dati situato in una porzione di memoria (una o più locazioni di memoria) destinata a contenere valori, suscettibili di modifica nel corso dell'esecuzione di un programma. Una variabile è caratterizzata da un nome (inteso solitamente come una sequenza di caratteri e cifre).

Una costante è un dato non modificabile situato in una porzione di memoria (una o più locazioni di memoria) destinata a contenere un valore, che non può essere appunto modificato nel corso dell'esecuzione di un programma. Una costante può essere caratterizzata da un nome (inteso solitamente come una sequenza di caratteri e cifre).

Nei linguaggi tipizzati, ciascuna variabile è caratterizzata da un tipo di dato, che specifica come deve essere considerato il dato rappresentato, e possibilmente restringe i valori accettabili. Ad esempio una variabile destinata a contenere il numero progressivo di un mese di una data, potrà assumere solo i valori interi da 1 a 12.

L'insieme delle variabili esistenti a tempo di esecuzione è contenuto all'interno dell'ambiente.

Definizione formale[modifica | modifica wikitesto]

La variabile è un identificatore V associato a un insieme prefissato di possibili valori che definiscono il tipo della variabile. L'insieme dei possibili valori definisce il range dei valori che V può assumere durante l'esecuzione di un programma. Definendo il tipo e la rappresentazione della variabile oltre al range di valori, vengono definite anche le operazioni possibili con la variabile stessa. Durante l'esecuzione di un programma ciascuna variabile ha un valore corrente.

Ambiti per concetto di variabile[modifica | modifica wikitesto]

Nei linguaggi di programmazione di livello diverso, il concetto di variabile ha sfumature diverse:

In assembly si trova il tipo più elementare di variabile: il registro, un contenitore di dati elementari interno al processore atto a contenere quelle informazioni numeriche che il processore stesso è in grado di manipolare direttamente alla massima velocità di processamento. Le uniche operazioni applicabili sui registri, sempre disponibili in numero molto limitato, sono quelle stabilite dal linguaggio macchina messo a disposizione dal processore stesso, quali assegnamento diretto o indiretto, test elementari, operazioni logiche o booleane. Solitamente l'assembler mette a disposizione del programmatore alcune caratteristiche di più alto livello, per facilitare la stesura del programma. Ad esempio, è possibile usare delle variabili o delle etichette: in questo caso, una variabile identifica un'area di memoria di una certa dimensione, non strettamente legata al tipo di dato che ospita, che accetta alcune operazioni elementari come la lettura, l'assegnamento, semplici operazioni logiche o aritmetiche. Una cella di memoria può essere opzionalmente identificata da un'etichetta (detta anche label), allo scopo di creare una semplice associazione mnemonica; resta tuttavia la possibilità di accedere ai suoi contenuti direttamente, mediante il proprio indirizzo.
In linguaggi che mantengono uno stretto legame con l'architettura hardware, come il C, o il C++ per i tipi di dati elementari, le variabili sono caratterizzate da un tipo, che limita le operazioni che possono essere fatte con la variabile dichiarata, e specializza la semantica degli operatori. Ad esempio, l'espressione a+b può essere valutata in modo diverso se a e b sono numeri interi oppure numeri in virgola mobile. È comunque possibile ottenere l'indirizzo di una variabile (per costruire un puntatore), e quindi manipolare manualmente l'utilizzo della memoria fatto dal compilatore.
In linguaggi che offrono un maggiore livello di astrazione, come Java, la variabile è tipizzata, ma il nome della variabile è l'unico modo per accedere al dato in essa memorizzato, e non è possibile conoscere l'indirizzo in cui è stata memorizzata. Una variabile di tipo complesso è in realtà sempre un riferimento a un'area di memoria allocata dinamicamente che viene gestito dal linguaggio.
Nei più semplici linguaggi di scripting interpretati, le variabili sono, di norma, solo semplici identificatori privi di un tipo e una dimensione definita. Lo spazio di memoria è allocato dinamicamente al momento dell'assegnamento.

Uso delle variabili[modifica | modifica wikitesto]

Nei linguaggi compilati, le variabili devono essere definite ovvero dichiarate in maniera tipizzata prima di essere adoperate, in quanto il compilatore o l'interprete non sa come trattare ovvero non riconosce oggetti sconosciuti ovvero non specificati precedentemente. La dichiarazione consente di raggiungere due fondamentali obiettivi: da un lato, con la dichiarazione tipizzata si specifica il tipo della variabile, cosicché il compilatore è in grado di verificare eventuali errori semantici presenti all'interno di un programma sintatticamente corretto (ad esempio, non è consentito moltiplicare tra loro una variabile stringa e una variabile intera). Dall'altro, viene valutata e definita la quantità di memoria destinata, in fase di esecuzione, a contenere i dati a cui la variabile si riferisce.

Le operazioni basilari che possono essere compiute su una variabile sono la lettura del valore in essa contenuto e la scrittura di un nuovo valore, o assegnamento. Il primo assegnamento della variabile è detto inizializzazione. Molti linguaggi richiedono o preferiscono che la variabile una volta dichiarata venga anche inizializzata a un valore arbitrario.

Dal punto di vista della semantica dei linguaggi di programmazione quando si dichiara tramite un identificativo o nome e si inizializza tramite un certo valore una variabile, il calcolatore riserva un contenitore ovvero un'area di memoria alla suddetta variabile ovvero crea un'associazione indirizzo cella di memoria-valore per tutto il tempo in cui la variabile stessa è attiva. In virtù della definizione di variabile l'associazione suddetta è dinamica ovvero il valore di questa può variare all'interno del flusso di esecuzione del programma comportando una sovrascrittura del valore precedente con quello attuale al punto o tempo t.

Per leggere il contenuto di una variabile v, cioè per utilizzarlo per qualche scopo del programma, basta impiegarne la sua notazione in un'espressione, come ad esempio in 5+v o in (3.14+v)*x.

In molti linguaggi di scripting, per indicare che si vuole leggere il valore di una variabile, bisogna aggiungere un prefisso e/o un suffisso al nome della variabile, come $HOME negli script di shell su unix, o %HOME% nei file batch su DOS.

Per assegnare un valore a una variabile, deve essere usato un operatore di assegnamento, ad esempio, in C, a = b + 5 assegna alla variabile a il risultato dell'espressione b+5 valutata nell'ambiente corrente.

Formalmente, un'espressione che può stare a sinistra di un operatore di assegnamento, ovvero qualcosa in cui può essere scritto un valore, è detta un l-value (contrazione di left-value). Una variabile è l'esempio tipico, ma non l'unico, di l-value. Un'espressione che può essere solo letta o valutata, ma alla quale non è possibile assegnare un valore, è detta r-value.

Visibilità di una variabile[modifica | modifica wikitesto]

Il contesto in cui una variabile viene dichiarata all'interno di un programma determina la sua visibilità (o portata o scope). Tutte le variabili visibili a tempo di esecuzione in un certo istante sono contenute nell'ambiente. Se più variabili dello stesso nome e dello stesso tipo vengono dichiarate in contesti diversi, è l'ambiente messo a disposizione dal linguaggio che determina in che modo le variabili sono visibili in ogni momento. Nei linguaggi più diffusi, ad esempio, il nome della variabile fa riferimento alla dichiarazione più specifica, ed esistono strumenti per indicare esplicitamente lo scope a cui si fa riferimento.

Si veda il seguente esempio:

 <begin blocco 1>
     var x:...            /* qui è visibile x */
     <begin blocco 1.1>
         var y:...        /* qui sono visibili x ed y */
     <end blocco 1.1>
     <begin blocco 1.2>
         var z:...        /* qui sono visibili x e z */
         <begin blocco 1.2.1>
             var y:...    /* qui sono visibili x, z e y */
         <end blocco 1.2.1>
     <end blocco 1.2>
 <end blocco 1>

Col termine variabili globali vengono generalmente indicate quelle variabili dichiarate al di fuori di un sottoblocco di programma, e che sono visibili in uno o più sottoblocchi, dipendentemente dalla struttura del programma stesso. L'uso di variabili globali è fortemente scoraggiato dalle pratiche di buona programmazione, poiché rischiano di generare interazioni di difficile controllo tra diverse parti di un programma. Nell'esempio, x è globale per il blocco 1.1, 1.2 ed 1.2.1.
- Nei linguaggi orientati agli oggetti, le variabili di classe o attributi sono visibili solo all'interno della istanze della classe in cui sono state dichiarate. In particolare, una variabile dichiarata come statica è unica per la classe, e condivisa da ogni sua istanza. In altre parole, in ogni istanza della classe tale attributo punta alla medesima area di memoria, pertanto una sua modifica effettuata in un'istanza si riflette in tutte le altre istanze della medesima classe.
Le variabili locali sono quelle definite all'interno di un sottoblocco, ad esempio all'interno di una funzione, e quindi visibili solo internamente al sottoblocco stesso, secondo il tipo di ambiente messo a disposizione dal linguaggio. Nell'esempio, le variabili y sono locali per ciascuno dei due blocchi, e sono distinte l'una dall'altra: la prima è locale in 1.1 e la seconda in 1.2.1. Infine, z è globale per il blocco 1.2.1 e locale per il blocco 1.2.
- Nei linguaggi orientati agli oggetti, gli attributi (non statici) di una classe sono elementi individuali di ogni distinta istanza. In tal caso, in ogni istanza tale attributo è presente localmente all'oggetto stesso, e distinto da quelli presenti in altre istanze della medesima classe.
- I parametri formali di una funzione sono assimilabili ai parametri locali dal punto di vista della visibilità.
- In molti linguaggi, è possibile dichiarare una variabile all'interno di un blocco di una struttura di controllo, o usare un costrutto di blocco solo per delimitare lo scope di una variabile locale, o ancora dichiarare una variabile all'interno di un'espressione. Queste variabili sono visibili solo all'interno del blocco o dell'espressione in cui sono dichiarate, come mostrato nell'esempio. Tali pratiche facilitano il mantenimento in vita di una variabile solo per il tempo strettamente necessario, in modo da consentire economia di memoria e pulizia nel testo del programma.