Llaves dentro de funcion

[m_villaizan]

Tengo una duda, cuando tengo una funcion como esta:

void main() {

int x, y,z;
x = 5;
y = 4;
z = x + y;

{
int y = 20;
}

cout << "x =" << x << " y =" << y << " z = " << z <<endl;

}

Yo se que el resultado al imprimir es que 'y' vale 4. Mi duda esta referida a la porcion de codigo que se ejecuta dentro de las llaves:

{
int y = 20;
}

Durante la ejecucion si se crea una nueva variable 'y' y si se le asigna el valor de 20, pero cuando termina 'y' sigue valiendo 4. Al abrir las llaves esto hace que esta porcion de codigo se ejcute pero que solo valga dentro de las llaves? y luego 'y' vuelve a tener el valor que le fue asignado fuera de las llaves? osea la 'y' declarada dentro de las llaves es otra 'y'? porque cuando hago el debug, la 'y' fuera de las llaves si cambia pero solo hasta terminar esa porcion de codigo, y luego vuelve a tener el valor de 4. Alguien me explica? Muchisimas gracias.

[reethok]

Al declarar "y" adentro de las llaves lo que haces es crear una variable LOCAL... que sólo existirá en el bloque en el que fue declarada (En este caso entre las 2 llaves).

Te recomiendo imprimir el valor de "y" también adentro del bloque, para que veas que adentro del bloque si va a valer 20, pero afuera volverá a valer 4.

Saludos!

[sam90]

Si compilas con GCC y la opcion -S te devuleve el codigo assembler del programa.

Código C:

int main() {
 
int x, y,z;
x = 5;
y = 4;
z = x + y;
 
{
int y = 20;
}
 
x = y;
return 0;
}
 

Código C:

.file   "h.c"
    .def    ___main;    .scl    2;  .type   32; .endef
    .text
.globl _main
    .def    _main;  .scl    2;  .type   32; .endef
_main:
    pushl   %ebp
    movl    %esp, %ebp
    subl    $24, %esp
    andl    $-16, %esp
    movl    $0, %eax
    addl    $15, %eax
    addl    $15, %eax
    shrl    $4, %eax
    sall    $4, %eax
    movl    %eax, -20(%ebp)
    movl    -20(%ebp), %eax
    call    __alloca
    call    ___main
    movl    $5, -4(%ebp)
    movl    $4, -8(%ebp)
    movl    -8(%ebp), %eax
    addl    -4(%ebp), %eax
    movl    %eax, -12(%ebp)
    movl    $20, -16(%ebp)
    movl    -8(%ebp), %eax
    movl    %eax, -4(%ebp)
    movl    $0, %eax
    leave
    ret
 

Por si no conoces algo de assembler, con movl asignas memoria, con add sumas.

Ahora analisemos un poco el codigo.

movl $5, -4(%ebp)


Esto esta asignando 5 a una parte de la memoria. En nuetro ejemplo teniamos x=5; por lo que deducimos que -4(%ebp) es la direccion de X (por asi decirlo).

movl $4, -8(%ebp)

Esto asigna 4 a -8(%ebp) por lo tanto es Y.



movl -8(%ebp), %eax
addl -4(%ebp), %eax
movl %eax, -12(%ebp)

Se carga Y en registro, se le suma X a ese registro y se guarda en -12(%ebp) que es Z.

movl $20, -16(%ebp)

Se asigna 20 a -16(%ebp). En nuetro codigo decia Y = 20; que estaba entre los corchetes, pero vemos que usa otra direccion, por lo tanto en el ambito este es como tener dos variables separadas. Nada mas que dentro de esas llaves tiene el mismo nombre que otra variable. Por lo que estamos haciendo inaccesible a la primer Y.

Espero haberte ayudado con tu duda. Yo acabo de aprender una nueva herramienta de C/c++.

[m_villaizan]

Muchisimas gracias a ambos, la parte de assembler lo deja todo muchismo mas claro para mí, ahora entiendo porque al hacer el debug es que el 'y' que esta afuera de las llaves pareciera no tener un valor a la hora de instanciar la que esta adentro, pero esto solo ocurre porque en el ambito no pueden haber 2 'y' claro que esta nueva 'y' usa otra direccion de memoria y a la hora de terminar el bloque la 'y' anterior sigue siendo la misma.

Muchas gracias.