Identificatori di classi di archiviazione per dichiarazioni di livello esterno

Le variabili esterne sono variabili nell'ambito file. Sono definite all'esterno di qualsiasi funzione e sono potenzialmente disponibili in molte funzioni. Le funzioni possono essere definite solo a livello esterno e, pertanto, non possono essere annidate. Per impostazione predefinita, tutti i riferimenti a variabili esterne e funzioni con lo stesso nome sono riferimenti allo stesso oggetto, ovvero hanno un collegamento esterno. È possibile usare la parola chiave per eseguire l'override static di questo comportamento.

Le dichiarazioni di variabili a livello esterno sono definizioni di variabili (dichiarazioni di definizione) o riferimenti a variabili definite altrove (dichiarazioni di riferimento).

Una dichiarazione di variabile esterna che inizializza anche la variabile (in modo implicito o esplicito) è una dichiarazione di definizione di variabile. Una definizione a livello esterno può assumere varie forme:

• Variabile dichiarata con l'identificatore static di classe di archiviazione. È possibile inizializzare in modo esplicito la static variabile con un'espressione costante, come descritto in Inizializzazione. Se si omette l'inizializzatore, la variabile viene inizializzata a 0 per impostazione predefinita. Ad esempio, le due istruzioni sono entrambe considerate definizioni della variabile k.

  static int k = 16;
  static int k;
  

• Una variabile che in modo esplicito viene inizializzata a livello esterno. Ad esempio, int j = 3; è una definizione della variabile j.

Nelle dichiarazioni di variabili a livello esterno ,ovvero all'esterno di tutte le funzioni, è possibile usare l'identificatore static della classe di archiviazione o extern o omettere completamente l'identificatore di classe di archiviazione. Non è possibile utilizzare i auto terminali e register storage-class-specifier a livello esterno.

Una volta che una variabile è definita a livello esterno, è visibile in tutto il resto dell'unità di conversione. La variabile non è visibile prima della dichiarazione nello stesso file di origine. Inoltre, non è visibile in altri file di origine del programma, a meno che una dichiarazione di riferimento non lo renda visibile, come descritto di seguito.

Le regole relative ad static includono:

• Le variabili dichiarate all'esterno di tutti i blocchi senza la static parola chiave mantengono sempre i relativi valori in tutto il programma. Per limitare l'accesso a una particolare unità di traduzione, è necessario usare la static parola chiave . In questo modo si ottiene un collegamento interno. Per renderli globali nell'intero programma, omettere la classe di archiviazione esplicita o utilizzare la parola chiave extern (vedere le regole nell'elenco seguente). In questo modo si ottiene un collegamento esterno. I collegamenti interni ed esterni vengono illustrati anche in Collegamento.

• È possibile definire una variabile a livello esterno una sola volta all'interno di un programma. È possibile definire un'altra variabile con lo stesso nome e l'identificatore static di classe di archiviazione in un'unità di conversione diversa. Poiché ogni static definizione è visibile solo all'interno della propria unità di conversione, non si verifica alcun conflitto. Offre un modo utile per nascondere i nomi degli identificatori che devono essere condivisi tra le funzioni di una singola unità di conversione, ma non visibili ad altre unità di conversione.

• L'identificatore static di classe di archiviazione può essere applicato anche alle funzioni. Se si dichiara una funzione static, il nome è invisibile all'esterno del file in cui viene dichiarato.

Le regole per l'utilizzo extern sono:

• L'identificatore classe di archiviazione extern dichiara un riferimento a una variabile definita altrove. È possibile usare una extern dichiarazione per rendere visibile una definizione in un altro file di origine o per rendere visibile una variabile prima della relativa definizione nello stesso file di origine. Dopo aver dichiarato un riferimento alla variabile a livello esterno, la variabile è visibile nel resto dell'unità di conversione in cui si verifica il riferimento dichiarato.

• Affinché un riferimento extern sia valido, la variabile cui si riferisce deve essere definita una e una sola volta a livello esterno. Questa definizione (senza la classe di archiviazione extern) può trovarsi in qualsiasi unità di conversione che costituisce il programma.

Esempio

Nell'esempio riportato di seguito vengono illustrate le dichiarazioni esterne:

/******************************************************************
                      SOURCE FILE ONE
*******************************************************************/
#include <stdio.h>

extern int i;                // Reference to i, defined below
extern void other ( void );  // Reference to other(), defined in second source file
void next( void );           // Function prototype

int main()
{
    i++;
    printf_s( "%d\n", i );   // i equals 4
    next();
}

int i = 3;                  // Definition of i

void next( void )
{
    i++;
    printf_s( "%d\n", i );  // i equals 5
    other();
}

/******************************************************************
                      SOURCE FILE TWO
*******************************************************************/
#include <stdio.h>

extern int i;              // Reference to i in
                           // first source file
void other( void )
{
    i++;
    printf_s( "%d\n", i ); // i equals 6
}

Nei due file di origine in questo esempio sono contenute in totale tre dichiarazioni esterne i. Una sola dichiarazione è una "dichiarazione di definizione". Tale dichiarazione,

int i = 3;

definisce la variabile globale i e la inizializza con valore iniziale 3. La dichiarazione "referencing" di nella parte superiore del primo file di i origine tramite extern rende visibile la variabile globale prima della dichiarazione di definizione nel file. La dichiarazione di riferimento i nel secondo file di origine rende visibile anche la variabile nel file di origine. Se un'istanza di definizione per una variabile non è disponibile nell'unità di conversione, il compilatore presuppone la presenza

extern int x;

di una dichiarazione di riferimento e che un riferimento di definizione

int x = 0;

viene visualizzato in un'altra unità di conversione del programma.

Tutte e tre le funzioni, main, next e other, eseguono la stessa attività: aumentano i e lo visualizzano. Vengono visualizzati i valori 4, 5 e 6.

Se la variabile i non fosse stata inizializzata, sarebbe stata impostata automaticamente su 0. In questo caso, sarebbero stati visualizzati i valori 1, 2 e 3. Per informazioni sull'inizializzazione delle variabili, vedere Inizializzazione.

Vedi anche

Classi di archiviazione C