Mejor respuesta
No confunda un tipo (como int) con otros aspectos de las declaraciones (por ejemplo, una clase de almacenamiento como static).
Es decir, en:
int x;
static int y;
x y y tienen el mismo tipo, int (el término “ datos tipo” se usa con menos frecuencia en C y C ++; sin embargo, no está mal).
La palabra clave static tiene tres significados diferentes en C. En el ejemplo anterior, indica esa variable y es «privada» para esa unidad de traducción en particular (ya que la unidad de traducción se puede considerar como un archivo fuente después de todas las #include directivas han sido procesados). Por tanto, una variable y declarada en otra unidad de traducción es distinta de esta.
A continuación, se muestra un ejemplo del segundo significado de static en C:
void f() {
static int n = 2;
...
}
Esta estática significa que la variable n se comparte entre todas las invocaciones de f() y permanece en existencia incluso después de que f() regrese (podría, por ejemplo, devolverle un puntero). La inicialización de n a 2 solo ocurre antes del inicio del programa en C (en la primera invocación de f() en C ++). Entonces, la segunda (y posterior) vez que se invoca f(), n mantendrá el valor que tenía antes (hasta que el programa lo modifique explícitamente nuevamente ).
El tercer significado es menos común (y creo que menos conocido):
void g(double x[static 5]) {
...
}
Esto indica que g() sólo se puede llamar con un puntero al primero de al menos 5 double valores en la formación de una matriz.
EDITAR: explicación fija de local inicialización estática como (ver el comentario de Jesse Pollard).
Respuesta
Estático es lo opuesto a dinámico. ¿Eh? Significa que la memoria asignada para esa variable no se mueve en la memoria. También significa que en llamadas repetidas a funciones que acceden a esa variable, no se crean nuevas instantáneas de la variable; se usa la variable original, y cualquier otra función que acceda a esa variable en esa dirección puede modificarla o leerla. No es per se una variable global; su alcance sigue siendo el mismo que dónde y cómo se definió. Sin embargo, podría serlo. Sin embargo, sería un error intentar definir otra variable estática con el mismo nombre en el mismo archivo o una incluida en una aplicación.
considere una función simple de C add:
int add(int a, int b)
{
static int count = 0;
static int last = 0;
count++;
last = a + b;
printf( "a:\t\%d \t\t b:\t\%d\n", a, b );
printf( "count:\t\%d \t\t last:\t\%d\n", count, last)
return last;
}
el recuento y el último se definen estáticos. Eso significa que los valores ingresados en ellos persisten en múltiples llamadas para agregar. count y last se inicializan a cero, pero luego no se vuelven a poner a cero en cada llamada. Observe que el alcance de count y last están dentro de la función add only. Es posible que no se compartan con otras funciones ni se acceda a ellos fuera de add, por lo que para acceder a ellos debe imprimirlos desde dentro de la función. Otras funciones también podrían tener un recuento idéntico y las últimas variables estáticas y nunca interactuarían.
Ahora mire este programa de prueba:
#include
static int count = 5;
static int last = 0;
int add(int a, int b)
{
static int count = 0;
static int last = 0;
count++;
last = a + b;
printf( "a:\t\%d \t\t b:\t\%d\n", a, b );
printf( "count:\t\%d \t\t last:\t\%d\n", count, last)
return last;
}
int main(int argc, char**argv )
{
static int count = 10;
static int last = 0;
int i;
int a=1, b=1;
for(i = 0 ; i < count ; i++)
{
a = add(a, b);
b = add(a, last);
last = add(a, b);
}
printf( "a:\t\%d \t\t b:\t\%d\n", a, b );
printf( "count:\t\%d \t\t last:\t\%d\n", count, last);
return 0;
}
Tres son 3 conjuntos de variables estáticas count y last; todos ellos están separados. Primero están los globales, nunca se usan aquí. main tiene su propio conjunto que usa porque sus vars locales hacen sombra a las globales. add tiene su propio conjunto que sombrea tanto a main como a globales con el mismo nombre.
Definiciones de funciones estáticas son un tipo diferente de cosas. La palabra estática indica que la función es visible solo en el archivo que se compila desde la fuente donde se define la función. Este es el archivo de origen (“.c”) o un encabezado (“.h) archivo incluido en él. Esto puede ser necesario si los archivos de objeto que está utilizando tienen más de una versión de una función con el mismo nombre (como agregar, imprimir, error,…) para que la combinación de archivos de objeto (“. O”) juntos como módulos no causan colisiones de nombres.