Identificatori di classi di archiviazione per dichiarazioni di livello esternoStorage-Class Specifiers for External-Level Declarations

Le variabili esterne sono variabili nell'ambito file.External variables are variables at file scope. Sono definite all'esterno di qualsiasi funzione e sono potenzialmente disponibili in molte funzioni.They are defined outside any function, and they are potentially available to many functions. Le funzioni possono essere definite solo a livello esterno e, pertanto, non possono essere annidate.Functions can only be defined at the external level and, therefore, cannot be nested. Per impostazione predefinita, tutti i riferimenti a variabili esterne e funzioni con lo stesso nome sono riferimenti allo stesso oggetto, ovvero presentano un "collegamento esterno".By default, all references to external variables and functions of the same name are references to the same object, which means they have "external linkage." È possibile usare la parola chiave static per eseguire l'override di questa operazione.(You can use the static keyword to override this. Per altre informazioni su static, vedere le informazioni più avanti in questa sezione.See information later in this section for more details on static.)

Le dichiarazioni di variabile a livello esterno sono definizioni delle variabili ("dichiarazioni di definizione") o riferimenti a variabili definite altrove ("dichiarazioni di riferimento").Variable declarations at the external level are either definitions of variables ("defining declarations"), or references to variables defined elsewhere ("referencing declarations").

Una dichiarazione di variabile esterna che inizializza anche la variabile (in modo implicito o esplicito) è una dichiarazione di definizione di variabile.An external variable declaration that also initializes the variable (implicitly or explicitly) is a defining declaration of the variable. Una definizione a livello esterno può assumere varie forme:A definition at the external level can take several forms:

  • Una variabile dichiarata con l'identificatore classe di archiviazione static.A variable that you declare with the static storage-class specifier. È possibile inizializzare in modo esplicito la variabile static con un'espressione costante, come descritto in Inizializzazione.You can explicitly initialize the static variable with a constant expression, as described in Initialization. Se si omette l'inizializzatore, la variabile viene inizializzata a 0 per impostazione predefinita.If you omit the initializer, the variable is initialized to 0 by default. Ad esempio, le due istruzioni sono entrambe considerate definizioni della variabile k.For example, these two statements are both considered definitions of the variable k.

    static int k = 16;  
    static int k;  
    
  • Una variabile che in modo esplicito viene inizializzata a livello esterno.A variable that you explicitly initialize at the external level. Ad esempio, int j = 3; è una definizione della variabile j.For example, int j = 3; is a definition of the variable j.

    Nelle dichiarazioni delle variabili a livello esterno (ovvero al di fuori di tutte le funzioni) è possibile usare l'identificatore classe di archiviazione static o extern oppure omettere completamente l'identificatore classe di archiviazione.In variable declarations at the external level (that is, outside all functions), you can use the static or extern storage-class specifier or omit the storage-class specifier entirely. Non è possibile usare i terminali storage-class-specifier auto e register a livello esterno.You cannot use the auto and register storage-class-specifier terminals at the external level.

    Una volta che una variabile è definita a livello esterno, è visibile in tutto il resto dell'unità di conversione.Once a variable is defined at the external level, it is visible throughout the rest of the translation unit. La variabile non è visibile prima della dichiarazione nello stesso file di origine.The variable is not visible prior to its declaration in the same source file. 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.Also, it is not visible in other source files of the program, unless a referencing declaration makes it visible, as described below.

    Le regole relative a static includono:The rules relating to static include:

  • Le variabili dichiarate all'esterno di tutti i blocchi senza la parola chiave static mantengono sempre i propri valori in tutto il programma.Variables declared outside all blocks without the static keyword always retain their values throughout the program. Per limitare tale accesso a un'unità di conversione particolare, è necessario usare la parola chiave static.To restrict their access to a particular translation unit, you must use the static keyword. In tal modo gli viene fornito un "collegamento interno".This gives them "internal linkage." Per renderli globali nell'intero programma, omettere la classe di archiviazione esplicita o utilizzare la parola chiave extern (vedere le regole nell'elenco seguente).To make them global to an entire program, omit the explicit storage class or use the keyword extern (see the rules in the next list). In tal modo gli viene fornito un "collegamento esterno".This gives them "external linkage." I collegamenti interni ed esterni vengono illustrati anche in Collegamento.Internal and external linkage are also discussed in Linkage.

  • È possibile definire una variabile a livello esterno una sola volta all'interno di un programma.You can define a variable at the external level only once within a program. È possibile definire un'altra variabile con lo stesso nome e l'identificatore classe di archiviazione static in un'unità di conversione diversa.You can define another variable with the same name and the static storage-class specifier in a different translation unit. Poiché ogni definizione static è visibile solo all'interno della relativa unità di conversione, non si verifica alcun conflitto.Since each static definition is visible only within its own translation unit, no conflict occurs. In tal modo si fornisce una modalità utile per nascondere i nomi degli identificatori che devono essere condivisi tra funzioni di una singola unità di conversione, ma non devono essere visibili alle altre unità di conversione.This provides a useful way to hide identifier names that must be shared among functions of a single translation unit, but not visible to other translation units.

  • L'identificatore classe di archiviazione static può essere applicato anche alle funzioni.The static storage-class specifier can apply to functions as well. Se si dichiara una funzione static, il nome è invisibile all'esterno del file in cui è dichiarata.If you declare a function static, its name is invisible outside of the file in which it is declared.

    Le regole per l'utilizzo extern sono:The rules for using extern are:

  • L'identificatore classe di archiviazione extern dichiara un riferimento a una variabile definita altrove.The extern storage-class specifier declares a reference to a variable defined elsewhere. È possibile utilizzare una dichiarazione extern per rendere visibile una definizione in un altro file di origine oppure per rendere visibile una variabile prima della definizione nello stesso file di origine.You can use an extern declaration to make a definition in another source file visible, or to make a variable visible prior to its definition in the same source file. Dopo aver dichiarato un riferimento alla variabile a livello esterno, la variabile è visibile in tutto il resto dell'unità di conversione in cui il riferimento viene dichiarato.Once you have declared a reference to the variable at the external level, the variable is visible throughout the remainder of the translation unit in which the declared reference occurs.

  • Affinché un riferimento extern sia valido, la variabile cui si riferisce deve essere definita una e una sola volta a livello esterno.For an extern reference to be valid, the variable it refers to must be defined once, and only once, at the external level. Questa definizione (senza la classe di archiviazione extern) può trovarsi in qualsiasi unità di conversione che costituisce il programma.This definition (without the extern storage class) can be in any of the translation units that make up the program.

EsempioExample

Nell'esempio riportato di seguito vengono illustrate le dichiarazioni esterne:The example below illustrates external declarations:

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

extern int i;                // Reference to i, defined below   
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.The two source files in this example contain a total of three external declarations of i. Una sola dichiarazione è una "dichiarazione di definizione".Only one declaration is a "defining declaration." La dichiarazione,That declaration,

int i = 3;  

definisce la variabile globale i e la inizializza con valore iniziale 3.defines the global variable i and initializes it with initial value 3. La dichiarazione "di riferimento" i all'inizio del primo file di origine che utilizza extern rende visibile la variabile globale prima della relativa dichiarazione di definizione nel file.The "referencing" declaration of i at the top of the first source file using extern makes the global variable visible prior to its defining declaration in the file. La dichiarazione di riferimento i nel secondo file di origine rende visibile anche la variabile nel file di origine.The referencing declaration of i in the second source file also makes the variable visible in that source file. Se un'istanza di definizione per una variabile non è disponibile nell'unità di conversione, il compilatore presuppone la presenzaIf a defining instance for a variable is not provided in the translation unit, the compiler assumes there is an

extern int x;  

di una dichiarazione di riferimento e che un riferimento di definizionereferencing declaration and that a defining reference

int x = 0;  

viene visualizzato in un'altra unità di conversione del programma.appears in another translation unit of the program.

Tutte e tre le funzioni, main, next e other, eseguono la stessa attività: aumentano i e lo visualizzano.All three functions, main, next, and other, perform the same task: they increase i and print it. Vengono visualizzati i valori 4, 5 e 6.The values 4, 5, and 6 are printed.

Se la variabile i non fosse stata inizializzata, sarebbe stata impostata automaticamente su 0.If the variable i had not been initialized, it would have been set to 0 automatically. In questo caso, sarebbero stati visualizzati i valori 1, 2 e 3.In this case, the values 1, 2, and 3 would have been printed. Per informazioni sull'inizializzazione delle variabili, vedere Inizializzazione.See Initialization for information about variable initialization.

Vedere ancheSee Also

Classi di archiviazione CC Storage Classes