Condividi tramite

Identificatori di classi di archiviazione per dichiarazioni di livello esterno

  • Articolo

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 dello stesso nome sono riferimenti allo stesso oggetto, ovvero hanno collegamenti esterni. È possibile usare la parola chiave per eseguire l'override di static questo comportamento.

Le dichiarazioni di variabile a livello esterno sono definizioni di variabili (dichiarazioni di definizione) o riferimenti alle variabili definite altrove (facendo riferimento alle 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 variabile a livello esterno , ovvero all'esterno di tutte le funzioni, è possibile usare l'identificatore o l'identificatore di classe di archiviazione o extern omettere interamente l'identificatore static di classe di archiviazione. Non è possibile usare i auto terminali e registerstorage-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 all'inclusione static :

  • Le variabili dichiarate all'esterno di tutti i blocchi senza la static parola chiave mantengono sempre i valori nel programma. Per limitare l'accesso a una determinata unità di traduzione, è necessario usare la static parola chiave. In questo modo viene fornito 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 viene fornito 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 traduzione diversa. Poiché ogni static definizione è visibile solo all'interno della propria unità di traduzione, 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 traduzione, ma non visibili ad altre unità di traduzione.

  • L'identificatore static della classe di archiviazione può essere applicato anche alle funzioni. Se si dichiara una funzione static, il nome è invisibile all'esterno del file in cui è 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 traduzione 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 i nella parte superiore del primo file di origine usando extern rende visibile la variabile globale prima della relativa 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 era 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