¿En qué momento exacto se almacena una variable local asignada?

Question

Supongamos que tenemos los siguientes:

void print() 
{ 
    int a; // declaration 
    a = 9; 
    cout << a << endl; 
} 

int main() 
{ 
    print(); 
} 

es el almacenamiento asignado para la variable a la función de impresión momento se llama en el principal o se trata de la ejecución, cuando llega la declaración dentro de la función?

Answer 1

Depende mucho del compilador, pero lógicamente el almacenamiento se asigna tan pronto como se declara la variable.

Considere esto simplista C++ ejemplo:

// junk.c++ 
int addtwo(int a) 
{ 
    int x = 2; 

    return a + x; 
} 

Cuando GCC compila esto, se genera el siguiente código (; comentarios mina):

.file "junk.c++" 
    .text 
.globl _Z6addtwoi 
    .type _Z6addtwoi, @function 
_Z6addtwoi: 
.LFB2: 
    pushl %ebp   ;store the old stack frame (caller's parameters and locals) 
.LCFI0: 
    movl %esp, %ebp  ;set up the base pointer for our parameters and locals 
.LCFI1: 
    subl $16, %esp  ;leave room for local variables on the stack 
.LCFI2: 
    movl $2, -4(%ebp) ;store the 2 in "x" (-4 offset from the base pointer) 
    movl -4(%ebp), %edx ;put "x" into the DX register 
    movl 8(%ebp), %eax ;put "a" (+8 offset from base pointer) into AX register 
    addl %edx, %eax  ;add the two together, storing the results in AX 
    leave     ;tear down the stack frame, no more locals or parameters 
    ret     ;exit the function, result is returned in AX by convention 
.LFE2: 
    .size _Z6addtwoi, .-_Z6addtwoi 
    .ident "GCC: (Ubuntu 4.3.3-5ubuntu4) 4.3.3" 
    .section .note.GNU-stack,"",@progbits 

Todo entre _Z6addtwoi y .LCFI2 es repetitivo código utilizado para configurar el marco de la pila (almacenar las variables de la función anterior, etc. de forma segura fuera del camino). El último "subl $ 16,% esp" es la asignación de la variable local x.

.LCFI2 es la primera parte del código de ejecución real que ha escrito. "movl $ 2, -4 (% ebp)" está poniendo el valor 2 en la variable. (Inicialización, en otras palabras.) Ahora su espacio se asigna Y se inicializa. Después de eso, carga el valor en el registro de EDX y lo sigue moviendo su parámetro, encontrado en "8 (% ebp)", en otro registro EAX. Luego agrega los dos juntos, dejando el resultado en EAX.Este es ahora el final de cualquier código que hayas escrito realmente. El resto nuevamente es solo repetitivo. Dado que GCC exige que los enteros se devuelvan en EAX, no es necesario realizar ningún trabajo para el valor de retorno. La instrucción "dejar" deshace el marco de la pila y la instrucción "ret" devuelve el control a la persona que llama.

TL; Resumen de DR: puede pensar que su espacio ha sido asignado con la primera línea de código ejecutable en su bloque (emparejado {}).

---

Pensé que limpiaría esto un poco con comentarios explicativos ya que esta es la respuesta seleccionada.

Answer 2

En cuanto a la construcción de objetos:

construcción suceda en el punto de la declaración, y se llama al destructor cuando el objeto sale del ámbito.

Pero no es necesario que la construcción de los objetos y la asignación de memoria coincidan.

Al igual que la destrucción de objetos y cuando la memoria se desasigna, no es necesario que coincida.

En cuanto a cuándo es en realidad la memoria asignada a la pila:

no sé, pero se puede comprobar a través del siguiente código:

void f() 
{ 
    int y; 
    y = 0;//breakpoint here 

    int x[1000000]; 
} 

Mediante la ejecución de este código se puede ver dónde ocurre la excepción, para mí en Visual Studio 2008 ocurre al ingresar la función. Nunca llega al punto de ruptura.

Answer 3

Esto dependerá del compilador, pero normalmente la variable int a se asignará a la pila en el momento de llamar a la función.

Answer 4

Al menos, como las cosas se implementan normalmente, está entre los dos. Cuando llama a una función, el compilador generará un código para la llamada de función que evalúa los parámetros (si los hay) y los coloca en registros o en la pila. Luego, cuando la ejecución llegue a la entrada de la función, se asignará espacio para las variables locales en la pila y se inicializarán las locales que necesitan inicialización. En ese momento, puede haber algún código para guardar los registros que utiliza la función, mezclar los valores para colocarlos en los registros deseados y demás. El código para el cuerpo de la función comienza a ejecutarse después de eso.

Answer 5

Como complemento a la respuesta de Brian R. Bondy: es bastante fácil realizar algunos experimentos para mostrar cómo funciona esto, con un poco más de detalle que lanzar errores fuera de la pila de espacio. Considere este código:

#include<iostream> 

void foo() 
{ 
    int e; std::cout << "foo:e " << &e << std::endl; 
} 

int main() 
{ 
    int a; std::cout << "a: " << &a << std::endl; 
    foo(); 
    int b; std::cout << "b: " << &b << std::endl; 
    { 
    int c; std::cout << "c: " << &c << std::endl; 
    foo(); 
    } 
    int d; std::cout << "d: " << &d << std::endl; 
} 

Esto produce esta salida en mi máquina:

$ ./stack.exe 
a: 0x28cd30 
foo:e 0x28cd04 
b: 0x28cd2c 
c: 0x28cd24 
foo:e 0x28cd04 
d: 0x28cd28 

Dado que la pila crece hacia abajo, podemos ver el orden en el que se ponen en la pila: a, b, d, y c en ese orden, y luego las dos llamadas a foo() ponen su e en el mismo lugar las dos veces. Esto significa que se ha asignado la misma cantidad de memoria en la pila las dos veces que se llama a foo(), aunque intervienen varias declaraciones de variables (incluida una dentro de un ámbito interno). Por lo tanto, en este caso podemos concluir que toda la memoria de la pila para las variables locales en main() se asignó al principio de main() en lugar de incrementarse incrementalmente.

También puede ver que el compilador arregla las cosas para que los constructores son llamados en orden descendente pila, y los destructores son llamados en orden ascendente - todo lo que es la parte inferior construida cosa en la pila cuando se construye y cuando es destruido , pero esto no significa significa que es lo último para lo que se ha asignado espacio, o que no hay espacio actualmente no utilizado encima de la pila para las cosas que no se han construido aún (como el espacio para d cuando c o las dos encarnaciones de foo: e están construidas).