Mi comprensión de las variables estáticas declaradas dentro de una función es:Declarar una variable estática nivel de función dentro de un bloque if que nunca se golpeó
- Si no se especifica ningún valor inicial, la variable estática residirá en
.bss
, de lo contrario en.data
- la memoria para la estática se asignan junto con globals - es decir, mucho antes de la ejecución entra
main
- son estos dos supuestos correctos ?
- Cuando la ejecución realiza la función por primera vez, la estática se inicializan al valor especificado por el usuario (o cero en caso de que no se especifica ningún valor inicial).
- ... y conservan sus valores a través de invocaciones posteriores de la función
Pero lo que si me declaro mi variable estática dentro de un bloque de if
? Supongo que mi tercer punto debe actualizarse al "cuando la ejecución llega a la línea donde se declara la variable estática, se inicializan en ..." - ¿estoy en lo cierto ?
Ahora, ¿qué pasa si el bloque if
en el que se declaran nunca se golpea (y el compilador puede resolverlo)? Entiendo que la variable nunca se inicializará; pero, ¿se asigna algún recuerdo para esa variable?
escribí dos funciones para tratar de averiguar lo que está pasando:
#include <stdio.h>
void foo()
{
static foo_var_out;
if(0){
static foo_var_in_0;
printf("%d %d\n", foo_var_in_0);
} else {
static foo_var_in_1;
printf("%d %d\n", foo_var_in_1);
}
}
static void bar(int flag)
{
static bar_var_out;
if(flag){
static bar_var_in_0;
printf("%d %d\n", bar_var_in_0);
} else {
static bar_var_in_1;
printf("%d %d\n", bar_var_in_1);
}
}
int main()
{
foo();
bar(0);
}
y yo tomamos el volcado de objeto:
$ gcc -o main main.c
$ objdump -t main | grep var
45:080495c0 l O .bss 00000004 foo_var_in_1.1779
46:080495c4 l O .bss 00000004 foo_var_out.1777
47:080495c8 l O .bss 00000004 bar_var_in_1.1787
48:080495cc l O .bss 00000004 bar_var_in_0.1786
49:080495d0 l O .bss 00000004 bar_var_out.1785
Desde la salida se ve como foo_var_in_0
no fue creada en absoluto (presumiblemente porque está dentro de un explícito if(0)
), mientras que bar_var_in_0
fue creado (ya que es posible que la persona que llama pase un valor distinto de cero, aunque el único que llama pasa explícitamente cero).
Supongo que mi pregunta es: ¿es correcto suponer que no se asignó memoria para la variable foo_var_in_0
en absoluto? Estoy preguntando sobre este caso específico; ¿Estoy leyendo el objdump correctamente, o debería estar haciendo algo más para verificar si la variable tomará algo de memoria mientras se ejecuta el programa?
En otras palabras, si la línea que declara una variable estática nivel de función no se ve afectado, es en realidad la variable declarada en absoluto?
Si no se creará en absoluto, es esto de acuerdo con el estándar C (menos probable), o una optimización de tiempo de compilación y en qué nivel - cómo lo enciendo/apaga (en gcc 4.1.1) ?
Entiendo que una int no es un gran problema que preocuparse, pero estoy más interesado en cómo funciona; Además, ¿qué pasaría si la variable tuviera una gran variedad de tamaños, digamos 5000 elementos de una estructura de 10 bytes?
ambos son creados por mí: http://pastebin.com/6cRbHWMJ (gcc MinGW 4.5.1) – Kos