una - se utilizo la variable local sin inicializar c++

¿Por qué este programa produce salida impar cuando la variable no está inicializada?

Question

int main() {
int j = 0;
int i = 0;
for (j = 0; j < 5; j++) {
printf("Iteration %d : %d ", j + 1, i);
int i;
printf("%d", i);
i = 5;
printf("/n");
}
}

El código anterior genera el siguiente resultado:

Iteration 1 : 0 0
Iteration 2 : 0 5
Iteration 3 : 0 5
Iteration 4 : 0 5
Iteration 5 : 0 5

No puedo entender por qué el segundo valor de printf en las iteraciones 2,3,4,5 es 5.

Mi comprensión de por qué el primer valor es 0 en cada iteración es que el alcance de i en el bucle for es local y se destruye tan pronto como entramos en una nueva iteración cuando i declararon en el ciclo for .

Pero no puedo entender por qué este valor se convierte en 5 en el segundo printf .

Answer 1

Creo que esto es lo que está sucediendo:

Breakpoint 1, main () at abc.c:4
4 int j = 0;
(gdb) s
5 int i = 0;
(gdb)
6 for(j=0;j<5;j++){
(gdb) p &i
$23 = (int *) 0x7fff5fbffc04 //(1) (addr = 0x7fff5fbffc04) i = 0
(gdb) p i
$24 = 0 // (2) i == 0
(gdb) s
7 printf("Iteration %d : %d ",j+1,i);
(gdb) p &i
$25 = (int *) 0x7fff5fbffc00 //(3) here compiler finds there is contention in variable ''i'' and assigns the inner one which is in present scope. Now, when subroutines are called, the stack frame is populated with (arguments, return address and local variables) and this is when the inner ''i'' was also got allocated in this inner loop block but not initialized yet and this is the reason i get garbage value in the first integration output.
(gdb) p i
$26 = 1606417440 // (4) Here i == 1606417440 (Garbage)
(gdb) s
9 printf("%d",i);
(gdb) s
10 i = 5;
(gdb) p &i
$27 = (int *) 0x7fff5fbffc00
(gdb) p i
$28 = 1606417440
(gdb) s
11 printf("/n");
(gdb) p &i
$29 = (int *) 0x7fff5fbffc00
(gdb) p i //(5) after executing previous statement, now i == 5
$30 = 5
(gdb)

Answer 2

El comportamiento de tu programa no está definido .

El alcance interno i no se inicializa en el punto en que se lee.

(Lo que podría estar sucediendo es que la i reintroducida en iteraciones posteriores ocupa la misma memoria que la encarnación anterior de la i interna, y la memoria no inicializada en la primera iteración corresponde a 0. Pero no confíe en eso. En otras ocasiones, el compilador podría comerse a tu gato.)

Answer 3

La segunda impresión en su programa está imprimiendo valor de basura de la variable local no inicializada i . En general, el comportamiento no está definido.

Por accidente, la ubicación de almacenamiento que representa su i (celda de memoria o registro de CPU) es la misma en cada iteración del ciclo. Por otro accidente, el cuerpo de su ciclo se ejecuta como una única declaración compuesta para cada iteración (en lugar de desenrollar el ciclo y ejecutar todas las iteraciones al mismo tiempo en forma intercalada). Por otro accidente, la ubicación de almacenamiento de i conserva su valor anterior de la iteración anterior. Por lo tanto, la basura que está imprimiendo coincide con el último valor almacenado de esa ubicación en la iteración anterior del ciclo.

Es por eso que ves 5 en local i en cada iteración además del primero. En la primera iteración, el valor de basura pasó a ser 0 .

Answer 4

Los compiladores de C tienen cierta flexibilidad en la forma en que implementan las cosas y no sería extraño que la "i" local no se vuelva a crear en realidad en cada pasada del ciclo. Es probable que en realidad solo se haya creado una vez y se haya reutilizado en cada pase. En este caso, su primera impresión está fuera del alcance de la variable local, por lo que usa i desde fuera del ciclo. La segunda impresión utiliza el i local tal como está en el alcance, y después de la primera iteración se ha establecido en 5. En la primera iteración, el valor correcto no está definido, no 0, pero el comportamiento de indefinido es específico de la implementación en su implementación parece que se inicializa automáticamente a 0.

Answer 5

Si declara una variable local y no le da un valor antes de usarla, si obtiene un comportamiento indefinido.

C estándar decir,

Las variables con duración de almacenamiento automática se inicializan cada vez que se ejecuta su instrucción de declaración. Las variables con la duración de almacenamiento automática declarada en el bloque se destruyen al salir del bloque.