Si declaro/defino un objeto en una sola declaración if , entonces ese objeto es visible solo dentro de la declaración if y se define y asigna solo si la condición if tiene éxito.
if(true) int x = 10; std::cout << x << '\n'; // error: x is not in scope Esto es realmente tan lógico, pero ¿por qué esto no se aplica también a la declaración de case ?
char c = 'b'; switch(c){ case 'a': int value; // ok. not-initialized break; case 'b': value = 100; // why still visible and when initialized? (this is an assignment) std::cout << value << '\n'; // 100 break; } Como puede ver, c tiene el valor b , por lo que el primer caso de etiqueta case 'a' no se ejecuta, por lo que cuando se define el value siempre que se defina un objeto cuando el control pasa a través de su definición.
¿Por qué el value es visible en el caso de la etiqueta case 'b' siempre que esté definido en una etiqueta de caso que no se ejecuta?
¿Cuál es el punto en permitir eso? (definiendo objetos, incluso la etiqueta de caso bajo la cual están definidos no coincide)?
El bloque de la instrucción switch comienza con la llave de apertura y se cierra con la de cierre. Las instrucciones de break no marcan ningún final de bloque.
Entonces ambos casos pertenecen al mismo bloque de instrucciones y comparten las mismas variables locales.
Para limitar la visibilidad de la variable a un bloque, debe agregar más llaves:
switch(c){ case 'a':{ int value; // ok. not-initialized } break; case 'b':{ value = 100; // You should get an error now std::cout << value << '\n'; // 100 } break; } Entonces, la pregunta restante es ¿por qué break no es un final de bloque? Diría eso porque el descanso puede ser condicional.
switch(c){ case 'a': int value; // ok. not-initialized if (condition) break; case 'b': value = 100; // It is normal in this case to be able to refer to previously defined variable std::cout << value << '\n'; // 100 break; }¡Aunque no veo un caso de uso real para tal código!
Una instrucción switch y una instrucción if son relativamente similares en la forma en que se compilan, es decir, ambas se traducen en un salto condicional en el ensamblado. La principal diferencia es que if las ramas son siempre mutuamente excluyentes, si ingresas if , nunca ingresas el else , pero las ramas switch no lo son. Por lo tanto, tiene sentido que el compilador se comporte en consecuencia.
Por lo general, insertamos un break al final de cada case porque, de lo contrario, también se ejecutarían las instrucciones de los siguientes case . Por ejemplo:
int x = 1; switch(x) { case 1: std::cout << "x was 1"; // No break! case 2: std::cout << "... But was it also 2?" << std::endl; break; default: break; }Salidas espeluznantes:
x era 1... ¿Pero también era 2?
Básicamente, el switch es una instrucción de salto, el case especifica dónde aterrizar pero no dice nada sobre saltar de nuevo. Ese trabajo se hace por break .
Usando las temidas declaraciones y etiquetas goto , un código muy similar sería este:
int x = 1; if (x == 1) goto x_was_1; else if (x == 2) goto x_was_2; else goto out; x_was_1: std::cout << "x was 1"; x_was_2: std::cout << "... But was it also 2?" << std::endl; goto out; out: // Rest of the code... Lo que da como resultado lo mismo. También puede ver cómo agregar un break es equivalente a agregar goto out en este caso.
En conclusión, el contenido de una declaración de switch es un solo bloque de código y todas las variables declaradas dentro de él son visibles porque puede recorrer todo el bloque. Al igual que espera que las variables se vean debajo de una break en un ciclo while , también puede esperar que sean visibles en este caso. Aunque creo que usar esto es una práctica extremadamente mala, muy ilegible y probablemente inútil.