Especificadores de clase de almacenamiento para las declaraciones de Externo- Nivel

Las variables externas son variables en el ámbito de archivo.Son definidas fuera de cualquier función, y son potencialmente disponibles para muchas funciones.Las funciones sólo pueden ser definido en el nivel externa y, por consiguiente, no pueden anidarse.De forma predeterminada, todas las referencias a variables externas y las funciones del mismo nombre son referencias al mismo objeto, lo que significa que tiene “vinculación externa.” (Puede utilizar la palabra clave de Estática para reemplazar esto.Vea información más adelante en esta sección para obtener información más detallada sobre Estática.)

Las declaraciones de variable en el nivel de externo son definiciones de variables (“definiendo declaraciones”), o referencias a variables definido en otra parte (“hacer referencia declaraciones”).

Una declaración de la variable externa que también inicializa la variable (implícita o explícitamente) es una declaración de definición de variable.Una definición en el nivel externo puede adoptar varias formas:

  • Una variable declarada con el especificador de clase de almacenamiento de Estática .Puede inicializar explícitamente la variable de Estática con una expresión constante, como se describe en inicialización.Si omite el inicializador, la variable se inicializa en 0 de forma predeterminada.Por ejemplo, estas dos instrucciones son ambas definiciones en cuenta de kvariable.

    static int k = 16;
static int k;

  • Una variable que explícitamente se inicializa en el nivel externo.por ejemplo, int j = 3; es una definición de jvariable.

En las declaraciones de variable en el nivel de externo (es decir, fuera de todas las funciones), puede utilizar el especificador de clase de almacenamiento de Estática o de extern u omitir el especificador de clase de almacenamiento completamente.No puede utilizar los elementosal almacenamiento-clase-especificador de Auto  y de Registrarseen el nivel externo.

Una vez que una variable se define en el nivel externo, está visible en el resto de la unidad de traducción.La variable no es visible antes de la declaración del mismo archivo de código fuente.Además, no es visible en otros archivos de código fuente del programa, a menos que una declaración que hace referencia a crearla visible, como se describe a continuación.

Las reglas relativos a la inclusión de Estática :

  • las variables declaradas fuera de todos los bloques sin la palabra clave de Estática conservan siempre sus valores en el programa.Para restringir el acceso a una unidad de traducción determinada, debe utilizar la palabra clave de Estática .Esto otorga “vinculación interna.” Para crearlos globales a todo un programa, omita la clase de almacenamiento explícita o utilizar la palabra clave extern (vea las reglas en la lista siguiente).Esto otorga “vinculación externa.” Vinculación interno y externo también se explica en Vinculación.

  • Puede definir una variable en el nivel exterior solo una vez dentro de un programa.Puede definir otra variable con el mismo nombre y el especificador de clase de almacenamiento de Estática en una unidad de traducción.Puesto que cada definición de Estática sea visible sólo dentro de su propia unidad de traducción, ningún conflicto se.Esto proporciona una manera útil de ocultar los nombres ID que se deben compartir entre funciones de una sola unidad de traducción, pero no visible a otras unidades de traducción.

  • El especificador de clase de almacenamiento de Estática puede aplicar a las funciones también.Si declara una función Estática, su nombre fuera no visible del archivo en el que se declara.

Las reglas para utilizar extern son:

  • El especificador de clase de almacenamiento de extern declara una referencia a un objeto definido variable en otra parte.Puede utilizar una declaración de extern para crear una definición en otro archivo de código fuente visible, o para crear una variable visible antes de la definición del mismo archivo de código fuente.Una vez que se ha declarado una referencia a la variable en el nivel externo, la variable está visible en el resto de la unidad de traducción en la que la referencia declarada aparece.

  • Para que una referencia de extern es válida, la variable que se hace referencia debe definirse una vez, y sólo una vez, en el nivel externo.Esta definición (sin la clase de almacenamiento de extern ) puede estar en unidades de traducción cualquiera de los que componen el programa.

Ejemplo

El ejemplo siguiente muestra declaraciones externas:

/******************************************************************
                      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 
}

Los dos archivos de código fuente de este ejemplo contienen un total de tres declaraciones externas de i.Sólo una declaración es una “definición de declaración”. Esta declaración,

int i = 3;

define la variable global i y se inicializa con el valor inicial 3.“Haga referencia” la declaración de i en la parte superior del primer archivo de código fuente utilizando extern crea la variable global visibles antes de la declaración de definición en el archivo.la declaración que hace referencia de i en el segundo archivo de código fuente también crea la variable visible en ese archivo de código fuente.Si una instancia de definición para una variable no aparecerá en la unidad de traducción, el compilador supone que hay

extern int x;

haciendo referencia a la declaración y que una referencia de definición

int x = 0;

en otra unidad de traducción del programa.

Las tres funciones, main, next, y other, realizan la misma tarea: aumentan i y se imprimen.se imprimen los valores 4, 5, y 6.

Si i variable no se hubiera inicializado, habría establecido en 0 automáticamente.En este caso, los valores 1, 2 y 3, habría sido impresos.Vea inicialización para obtener información sobre la inicialización variable.

Vea también

Referencia

Clases de almacenamiento de C

  • Last updated on