Sentencia switch en C++: casos, fall-through y break

Para qué sirve switch

Un switch compara un valor contra una lista de opciones fijas y ejecuta la rama que coincide. Cuando te encuentras escribiendo una larga cadena de if/else if que sigue comprobando la misma variable contra distintas constantes, un switch expresa esa intención con más claridad, y a menudo compila a una tabla de saltos más rápida.

Solo hace comprobaciones de igualdad contra constantes en tiempo de compilación sobre un valor de tipo entero. No puede comprobar rangos, comparar cadenas ni combinar condiciones. Para cualquiera de esos casos, quédate con if/else.

El switch básico

Le das a switch un valor y luego enumeras etiquetas case para los valores que te importan. Cada rama termina con break:

#include <iostream>
using namespace std;

int main() {
    int day = 3;

    switch (day) {
        case 1:
            cout << "Monday" << endl;
            break;
        case 2:
            cout << "Tuesday" << endl;
            break;
        case 3:
            cout << "Wednesday" << endl;
            break;
        default:
            cout << "Some other day" << endl;
            break;
    }

    return 0;
}

El valor 3 coincide con case 3:, así que se imprime "Wednesday" y break salta fuera del switch. La rama default es el caso general: se ejecuta cuando ningún case coincide. Es opcional, pero inclúyela a menos que estés seguro de que todos los valores están contemplados.

Fíjate en que las etiquetas case son constantes sueltas seguidas de dos puntos, no condiciones. Escribes case 3:, nunca case day == 3:.

break y fall-through

Este es el problema más importante de switch en C++. Después de que un case coincide, la ejecución no se detiene en el siguiente case: sigue corriendo de largo hasta encontrar un break o la llave de cierre. Mira lo que ocurre cuando faltan las sentencias break:

#include <iostream>
using namespace std;

int main() {
    int level = 1;

    switch (level) {
        case 1:
            cout << "one" << endl;
        case 2:
            cout << "two" << endl;
        case 3:
            cout << "three" << endl;
        default:
            cout << "done" << endl;
    }

    return 0;
}

Podrías esperar solo "one". En cambio se imprimen las cuatro líneas: al coincidir con case 1: se entra al switch ahí y luego se cae a través de todas las etiquetas que hay debajo. Añade un break; después de cada rama y obtendrás la única línea que querías. Olvidar un break es la fuente clásica de los errores del tipo "¿por qué mi switch ejecuta demasiado código?".

Fall-through intencional para agrupar casos

El fall-through no siempre es un error: es la forma idiomática de hacer que varios casos compartan un mismo cuerpo. Deja los casos vacíos (sin sentencias, sin break) y todos fluyen al siguiente bloque:

#include <iostream>
using namespace std;

int main() {
    char grade = 'B';

    switch (grade) {
        case 'A':
        case 'B':
        case 'C':
            cout << "Pass" << endl;
            break;
        case 'D':
        case 'F':
            cout << "Fail" << endl;
            break;
        default:
            cout << "Invalid grade" << endl;
    }

    return 0;
}

'A', 'B' y 'C' aterrizan todos en la misma línea "Pass" porque los dos primeros casos están vacíos y caen a través hacia el tercero. Esto es limpio e intencionado. Cuando sí quieres caer a través después de ejecutar algo de código, documéntalo con un comentario, o en C++17 y posteriores, con el atributo [[fallthrough]];, que le dice al compilador "sí, esto fue a propósito" y silencia las advertencias de fall-through.

switch sobre enums

switch combina de forma natural con los enums, ya que un enum es exactamente "uno de un conjunto fijo de valores". Los compiladores también pueden advertirte si olvidas tratar uno de los enumeradores:

#include <iostream>
using namespace std;

enum class Direction { North, East, South, West };

int main() {
    Direction d = Direction::East;

    switch (d) {
        case Direction::North:
            cout << "Heading up" << endl;
            break;
        case Direction::East:
            cout << "Heading right" << endl;
            break;
        case Direction::South:
            cout << "Heading down" << endl;
            break;
        case Direction::West:
            cout << "Heading left" << endl;
            break;
    }

    return 0;
}

Con un enum class con alcance debes calificar cada etiqueta (Direction::East). Como todos los enumeradores están cubiertos, no hace falta default, y muchos compiladores te advertirán si más adelante añades una quinta dirección y olvidas añadir su caso. Esa ayuda del compilador es una gran razón para preferir switch sobre las cadenas de if/else con enums.

Un problema: declaraciones dentro de un case

No puedes declarar una variable con un inicializador en un case y que sea visible en los demás casos sin darle su propio alcance. Este es un error de compilación común:

switch (x) {
    case 1:
        int n = 10;   // error: el salto a case 2 omite esta inicialización
        cout << n;
        break;
    case 2:
        cout << "two";
        break;
}

El compilador lo rechaza porque caer dentro de case 2: saltaría por encima de la inicialización de n mientras n sigue en alcance. La solución es envolver el cuerpo del case en sus propias llaves, dándole a la variable un bloque propio:

#include <iostream>
using namespace std;

int main() {
    int x = 1;

    switch (x) {
        case 1: {
            int n = 10;   // ahora con alcance a este bloque, correcto
            cout << n << endl;
            break;
        }
        case 2:
            cout << "two" << endl;
            break;
    }

    return 0;
}

Siempre que un case necesite su propia variable local, dale llaves. Además evita que la variable se filtre a los casos de abajo.

Siguiente: bucle for

switch e if permiten que tu programa elija qué código ejecutar una vez. Pero mucho trabajo implica hacer lo mismo muchas veces: contar, recorrer una lista, repetir hasta que una condición cambie. El bucle for es el caballo de batalla para eso, y es la siguiente página.