• Programmazione » Programmazione » Guida C - Manuale programmazione con articoli e risorse interessanti

L'ACCESSIBILITÀ' E LA DURATA DELLE VARIABILI

Le variabili static 

Una variabile è static se dichiarata utilizzando, appunto, la parola chiave static: 

static float sF, *sFptr;

Nell'esempio sono dichiarate due variabili static: una di tipo float e un puntatore (static anch'esso) ad un float. 

Come nel caso delle variabili automatic, quelle static sono locali al blocco di codice in cui sono dichiarate (e dunque sono accessibili solo all'interno di esso). La differenza consiste nel fatto che le variabili static hanno durata estesa a tutto il tempo di esecuzione del programma. Esse, pertanto, esistono già prima che il blocco in cui sono dichiarate sia eseguito e continuano ad esistere anche dopo il termine dell'esecuzione del medesimo. 

Ne segue che i valori in esse contenuti sono persistenti; quindi se il blocco di codice viene nuovamente eseguito esse si presentano con il valore posseduto al termine dell'esecuzione precedente. 

In altre parole, il compilatore alloca in modo permanente alle variabili static la memoria loro necessaria. 

Il tutto può essere chiarito con un paio di esempi: 

#include

void incrementa(void)
{
    int x = 0;

    ++x;
    printf("%d
" ,x);
}

void main(void)
{
    incrementa();
    incrementa();
    incrementa();
}

Il programma chiama la funzione incrementa() 3 volte; ad ogni chiamata la variabile x, automatic, è dichiarata ed inizializzata a 0. Essa è poi incrementata e visualizzata. L'output del programma è il seguente: 

1
1
1

Infatti x, essendo una variabile automatic, "sparisce" al termine dell'esecuzione della funzione in cui è dichiarata. Ad ogni chiamata essa è nuovamente allocata, inizializzata a 0, incrementata, visualizzata e... buttata alle ortiche. Indipendentemente dal numero di chiamate, incrementa() visualizza sempre il valore 1. 

Riprendiamo ora la funzione incrementa(), modificando però la dichiarazione di x: 

void incrementa(void)
{
    static int x = 0;

    ++x;
    printf("%d
" ,x);
}

Questa volta x è dichiarata static. Vediamo l'output del programma: 

1
2
3

La x è inizializzata a 0 solo una volta, al momento della compilazione. Durante la prima chiamata ad incrementa(), essa assume pertanto valore 1. Poiché x è static, il suo valore è persistente e non viene perso in uscita dalla funzione. Ne deriva che alla seconda chiamata di incrementa() essa assume valore 2 e, infine, 3 alla terza chiamata. 

Quando si specifica un valore iniziale per una variabile automatic, detto valore è assegnato alla variabile ogni volta che viene eseguito il blocco in cui la variabile stessa è dichiarata. Una inizializzazione come: 

{
    int x = 1;
    ....

non è che una forma abbreviata della seguente: 

{
    int x;

    x = 1;
    ....

Quanto detto non è vero per le variabili static. Il valore iniziale di 1 nella seguente riga di codice: 

static int x = 1;

viene assegnato alla variabile x una sola volta, in fase di compilazione: il compilatore riserva spazio per la variabile e vi memorizza il valore iniziale. Quando il programma è eseguito, il valore iniziale della variabile è già presente in essa. 

Se il programmatore non inizializza esplicitamente una variabile static, il compilatore le assegna automaticamente il valore NULL, cioè lo zero. 

Va poi sottolineato che l'accessibilità di una variabile static è comunque limitata (come per le varibili automatic) al blocco di codice in cui è dichiarata. Nel programma riportato per esempio, la variabile x non è accessibile né in main() né in qualunque altra funzione eventualmente definita, ma solamente all'interno di incrementa(). 

Infine, è opportuno ricordare che un array dichiarato in una funzione deve necessariamente essere dichiarato static se inizializzato contestualmente alla dichiarazione.