Ver el código de «cpp/language/switch»

No tienes permiso para modificar esta página, por el siguiente motivo:
La acción que has solicitado está restringida a los usuarios de uno de estos 2 grupos: Usuarios, Administradores.
Puedes ver y copiar el código fuente de esta página.
{{title|Instrucción {{tt|switch}}}}
{{cpp/language/statements/navbar}}
Transfiere control a una de varias instrucciones, dependiendo del valor de una condición.

===Sintaxis===
{{sdsc begin}}
{{sdsc|1=
{{spar|atrib}}{{mark optional}} {{ttb|switch}} {{ttb|(}} {{spar|instrucción-de-inicialización}}{{mark optional}} {{spar|condición}} {{ttb|)}} {{spar|instrucción}} 
}}
{{sdsc end}}

{{par begin}}
{{par | {{spar|atrib}}{{mark since c++11}} | Cualquier número de {{rlp|attributes|atributos}} }}
{{par | {{spar|instrucción-<br>de-inicialización}} | {{mark since c++17}} O bien 
* Una {{rlp|statements#Instrucciones de expresión|instrucción de expresión}} (que puede ser una ''instrucción nula'' "{{ttb|;}}")
* Una {{rlp|declarations|declaración simple}}, típicamente una declaración de una variable con un inicializador, pero puede declarar varias variables arbitrarias {{rev inl|since=c++17|o {{rlp|structured binding|vínculos estructurados}}}}. 
{{rrev|since=c++23|
* una {{rlp|type alias|declaración de alias}}
}}
:Ten en cuenta que cualquier {{spar|instrucción-de-inicialización}} debe terminar con un punto y coma {{ttb|;}}, la razón por la cual frecuentemente se describe informalmente como una expresión o una declaración seguida por un punto y coma.}}
{{par | {{spar|condición}} | Cualquier {{rlp|expressions|expresión}} de tipo entero o enumeración, o de un tipo de clase {{rlp|implicit cast|contextualmente implícitamente convertible}} a un tipo entero o enumeración, o una {{rlp|declarations|declaración}} de una variable simple no ''array'' de tal tipo con un {{rlp|initialization|inicializador}} con llaves o el signo igual.}}
{{par | {{spar|instrucción}} | Cualquier {{rlp|statements|instrucción}} (típicamente una instrucción compuesta). Las etiquetas {{ttb|case:}} y {{ttb|default:}} se permiten en la {{spar|instrucción}}, y la instrucción {{c|break;}} tiene un significado especial.}}
{{par end}}

{{sdsc begin}}
{{sdsc|num=1|1=
{{spar|atrib}}{{mark optional}} {{ttb|case}} {{spar|expresión_constante}} {{ttb|:}} {{spar|instrucción}}
}}
{{sdsc|num=2|1=
{{spar|atrib}}{{mark optional}} {{ttb|default}} {{ttb|:}} {{spar|instrucción}}
}}
{{sdsc end}}

{{par begin}}
{{par | {{spar|expresión_constante}} | Una expresión constante del mismo tipo que el tipo de la {{spar|condición}} después de las conversiones y {{rlp|implicit_cast|promociones enteras}}.}}
{{par end}}

===Explicación===
El cuerpo de una instrucción {{tt|switch}} puede tener un número arbitrario de etiquetas {{tt|case:}}, siempre y cuando los valores de todas las {{spar|expresiones_constantes}} sean únicas (después de conversiones o promociones). A lo sumo, puede estar presente una etiqueta {{tt|default:}} (aunque las etiquetas {{tt|switch}} anidadas pueden usar sus propias etiquetas {{tt|default:}} o tener etiquetas {{tt|case:}} cuyas constantes son idénticas a las utilizadas en la instrucción {{tt|switch}} circundante).

Si la {{spar|condición}} se evalúa al valor que es igual al valor de una de las {{spar|expresiones_constantes}}, entonces el control se transfiere a la instrucción que está etiquetada con esa {{spar|expresión_constante}}.

Si la {{spar|condición}} se evalúa al valor que no corresponde con ninguna de las etiquetas {{tt|case:}}, y está presente la etiqueta {{tt|default:}}, el control se transfiere a la instrucción etiquetada con la etiqueta {{tt|default:}}.

Si la {{spar|condición}} se evalúa a un valor que no corresponde con ninguna de las etiquetas {{tt|case:}}, y no está presente la etiqueta {{tt|default:}}, entonces no se ejecuta ninguna instrucción del cuerpo del switch.

La instrucción {{rlp|break}}, cuando se encuentra en la {{spar|instrucción}} sale de la instrucción {{tt|switch}}:

{{source|switch(1) {
    case 1 : cout << '1'; // imprime "1",
    case 2 : cout << '2'; // luego imprime "2"
}
}}
{{source|switch(1) {
    case 1 : cout << '1'; // imprime "1"
             break;       // y abandona switch
    case 2 : cout << '2';
             break;
}
}}

{{rev begin}}
{{rev|since=c++17|
Los compiladores pueden emitir advertencias de caída (''fallthrough'') (al alcanzar la siguiente etiqueta {{tt|case}} sin {{tt|break}}) a menos que el atributo {{rlp|attributes|atributo}} {{attr|fallthrough}} aparezca inmediatamente antes de la etiqueta {{tt|case}} para indicar que la caída es intencionada.

Si se utiliza la {{spar|instrucción-de-inicialización}}, la instrucción {{tt|switch}} es equivalente a

{{sdsc begin}}
{{sdsc | 
{{ttb|{}}<br>
:{{spar|instrucción_de_inicialización}} <br>
:{{ttb|switch}} {{ttb|(}} {{spar|condición}} {{ttb|)}} {{spar|instrucción}} <br>
{{ttb|} }}
}}
{{sdsc end}}
Excepto que los nombres declarados por la {{spar|instrucción-de-inicialización}} (si la {{spar|instrucción-de-inicialización}} es una declaración) y los nombres declarados por la {{spar|condición}} (si la condición es una declaración) se encuentran en el mismo ámbito, el cual también es el ámbito de la {{spar|instrucción}}.
}}{{rev end}}

Como la transferencia de control {{rlp|goto|no se permite que entre al ámbito}} de una variable, si se encuentra una instrucción de declaración dentro de la {{spar|instrucción}}, tiene que ponerse dentro de un ámbito en su propia instrucción compuesta:

{{source|1=switch(1) {
    case 1: int x = 0; // inicialización
            std::cout << x << '\n';
            break;
    default: // error de compilación: salto a default: 
             // entraría al ámbito de 'x' sin inicializarla
             std::cout << "default\n";
             break;
}
}}

{{source|1=switch(1) {
    case 1: {  int x = 0;
               std::cout << x << '\n';
               break;
            } // aquí termina el ámbito de 'x'
    default: std::cout << "default\n"; // no hay error
             break;
}
}}

===Palabras clave===

{{ltt|cpp/keyword/switch}},
{{ltt|cpp/keyword/case}},
{{ltt|cpp/keyword/default}}

===Ejemplo===
{{example
 | El siguiente código muestra varios usos de la instrucción {{tt|switch}}:
 | code=
#include <iostream>

int main()
{
    const int i = 2;
    switch (i) {
        case 1: std::cout << "1";
        case 2: std::cout << "2";   // ejecución comienza en esta etiqueta case
        case 3: std::cout << "3";   [[fallthrough]]; // atributo de C++17 para ignorar
        case 4:                                      // el aviso de caída
        case 5: std::cout << "45";
                break;              // termina ejecución de instrucciones subsequentes
        case 6: std::cout << "6";
    }
    
    std::cout << '\n';
    
    switch (i) {
        case 4: std::cout << "a";
        default: std::cout << "d"; // no hay expresiones_constantes aplicables
                                   // por lo tanto se ejecuta default
    }

    std::cout << '\n';

    switch (i) {
        case 4: std::cout << "a";  // no se ejecuta nada
    }

    // cuando se usan enumeraciones en una instrucción switch, algunos compiladores
    // emiten advertencias si uno de los enumerados no se incluye
    enum color {ROJO, VERDE, AZUL};
    switch(ROJO) {
        case ROJO:   std::cout << "rojo\n"; break;
        case VERDE: std::cout << "verde\n"; break;
        case AZUL:  std::cout << "azul\n"; break;
    }

    // La sintaxis de la instrucción-de-inicialización de C++17 puede ser útil cuando
    // no hay una conversión implícita a un tipo entero o de enumeración
    struct Dispositivo {
        enum { REPOSO, LISTO, MAL } estado_{};
        /*...*/
        auto estado() const { return estado_; }
    };
    switch (auto disp = Dispositivo{}; disp.estado())
    {
       case Dispositivo::REPOSO: /*...*/ break;
       case Dispositivo::LISTO: /*...*/ break;
       case Dispositivo::MAL: /*...*/ break;
    }

    // ejemplos patológicos

    // la instrucción no tiene que ser una instrucción compuesta
    switch(0)
        std::cout << "esto no hace nada\n";

    // las etiquetas tampoco requieren una instrucción compuesta
    switch(int n = 1)
        case 0:
        case 1: std::cout << n << '\n';
    // Dispositivo de Duff: https://es.wikipedia.org/wiki/Dispositivo_de_Duff
    // Más completa en inglés: https://en.wikipedia.org/wiki/Duff
}
 | output=
2345
d
rojo
1
}}

===Véase también===
{{dsc begin}}
{{dsc|[[enwiki:Duff's_device|Loop unrolling using Duff's Device]]}}
{{dsc|[[enwiki:Coroutine#Implementations for C|Duff's device can be used to implement coroutines in C/C++]]}}
{{dsc see c | c/language/switch}}
{{dsc end}}

{{langlinks|ar|de|en|fr|it|ja|pt|ru|zh}}
Plantillas usadas en esta página:
Volver a cpp/language/switch.
cppreference.com

Buscar

Espacios de nombres

Variantes

Vistas

Acciones

Ver el código de «cpp/language/switch»

Navegación

Herramientas
