Las sentencias switch en C++

1. la instrucción switch-case en C++
2. Reglas y propiedades en el uso de Switch Case en C++
3. Diferencia entre declaraciones switch y declaraciones if-else en C++

En este artículo, aprenderemos sobre las sentencias switch en C++ y sus propiedades especiales.

la instrucción switch-case en C++

El switch-case evalúa la expresión, en función de su valor, y se prueba con una lista de valores constantes presentes en las declaraciones case para realizar diferentes acciones basadas en diferentes cases.

Al igual que if-else, las sentencias switch son sentencias de flujo de control porque pueden alterar el flujo general de un programa porque permite que una expresión o una variable controlen el flujo a través de una ramificación multidireccional.

Sintaxis:

switch(variable / expression)
{
case constant-expression 1:
  statements;

case constant-expression 2:
  statements;
}

Código de ejemplo:

#include <iostream>
using namespace std;

int main() {
  int day = 3;
  switch (day) {
    case 1:
      cout << "Monday\n";

    case 2:
      cout << "Tuesday\n";

    case 3:
      cout << "Wednesday\n";

    case 4:
      cout << "Thursday\n";

    case 5:
      cout << "Friday\n";

    case 6:
      cout << "Saturday\n";

    case 7:
      cout << "Sunday\n";
  }
}

Producción :

Wednesday
Thursday
Friday
Saturday
Sunday

El valor de la variable day = 3 es evaluado y emparejado con la respectiva sentencia case que es case 3, y la sentencia que contiene que es "Wednesday" es impresa, pero aún así obtenemos las cadenas restantes porque una vez que el control va al case 3, todo desde allí hasta el final del bloque switch, todas las sentencias son impresas/evaluadas.

Por eso se imprimen las sentencias de los casos 4,5,6,7.

Para evitar esto, tenemos que modificar nuestra estructura switch-case.

Sintaxis - Modificado switch-case:

switch(variable / expression)
{
case constant-expression 1:
  statements;
  break; (optional)

case constant-expression 2:
  statements;
  break; (optional)

default:  //default statment optional
  statements;
  break;
}

La palabra clave break se utiliza para detener la ejecución del bloque interruptor y salir de él. Una vez que la condición/caso coincide, evaluamos las declaraciones, interrumpimos el flujo y salimos del bloque de cambio.

La palabra clave default especifica declaraciones ejecutadas cuando no coincide ningún caso.

Código de ejemplo:

#include <iostream>
using namespace std;

int main() {
  int day = 3;
  switch (day) {
    case 1:
      cout << "Monday\n";
      break;
    case 2:
      cout << "Tuesday\n";
      break;

    case 3:
      cout << "Wednesday\n";
      break;
    case 4:
      cout << "Thursday\n";
      break;

    case 5:
      cout << "Friday\n";
      break;

    case 6:
      cout << "Saturday\n";
      break;

    case 7:
      cout << "Sunday\n";
      break;

    default:
      cout << "Wrong option entereted\n";
      break;
  }
}

Producción :

Wednesday

En el siguiente ejemplo, también podemos cambiar con char. Veremos un código de ejemplo que verifica si un carácter es una vocal o una consonante.

Código de ejemplo:

#include <iostream>
using namespace std;

int main() {
  char x = 'u';

  switch (x) {
    case 'a':
      cout << "Vowel";
      break;
    case 'e':
      cout << "Vowel";
      break;
    case 'i':
      cout << "Vowel";
      break;
    case 'o':
      cout << "Vowel";
      break;
    case 'u':
      cout << "Vowel";
      break;

    default:
      cout << "Consonant";
      break;
  }
}

Producción :

Vowel

Reglas y propiedades en el uso de Switch Case en C++

1. La expresión utilizada dentro de la instrucción switch debe ser un valor constante. De lo contrario, se considerará inválido.

Aquí podemos ver que se pueden utilizar expresiones constantes y variables siempre que se les asignen valores fijos.

```c++
switch (1 + 2 + 3 * 4 + 5)
  switch (a + b + c * d)
```

2. default y break son opcionales. Aunque el switch-case no los tenga, se ejecutará sin ningún problema.

3. El anidamiento de sentencias switch es válido, significa que podemos cambiar sentencias dentro de otra. Aunque no es una buena práctica de programación, aún podemos utilizarlos.

   #include <iostream>
   using namespace std;
   
   int main() {
     int ID = 1234;
     int password = 000;
   
     switch (ID) {
       case 1234:
         cout << "checking info......\n";
   
         switch (password) {
           case 000:
             cout << "Login successful\n";
             break;
           default:
             cout << "Password don't match please check it\n";
             break;
         }
   
         break;
   
       default:
         printf("incorrect ID");
         break;
     }
   }
   

   Producción:

   checking info......
   Login successful
   

4. La expresión utilizada dentro de la instrucción switch debe ser de tipo integral, lo que significa que debe ser int, char o enum. De lo contrario, obtenemos un error de compilación.

   #include <iostream>
   using namespace std;
   
   int main() {
     float x = 12.34;
   
     switch (x) {
       case 1.1:
         cout << "Yes";
         break;
       case 12.34:
         cout << "NO";
         break;
     }
   }
   

   Producción:

   [Error] switch quantity not an integer
   

5. El bloque default puede estar dentro de switch pero solo se ejecuta cuando no hay casos coincidentes.

   #include <iostream>
   using namespace std;
   
   int main() {
     int x = 45;
     switch (x) {
       default:
         cout << "It's not 1 or 2";
         break;
       case 1:
         cout << "It's a 1";
         break;
       case 2:
         cout << "It's a 2";
         break;
     }
   }
   

   Producción:

   It's not 1 or 2
   

6. Las declaraciones escritas arriba del caso nunca se ejecutan. Una vez que se evalúa la instrucción switch, el control cambia al caso coincidente o al bloque default, si está presente.

   #include <iostream>
   using namespace std;
   
   int main() {
     int x = 45;
     switch (x) {
       cout << "Tony is Iron Man\n";
       case 1:
         cout << "It's a 1";
         break;
       case 2:
         cout << "It's a 2";
         break;
   
       default:
         cout << "It's not 1 or 2";
         break;
     }
   }
   

   Producción:

   It's not 1 or 2
   

7. No se permiten etiquetas de cajas duplicadas. Si se da, obtendremos un error de compilación.

   #include <iostream>
   using namespace std;
   
   int main() {
     int x = 45;
     switch (x) {
       case 45:
         cout << "Iron Man";
         break;
   
       case 40 + 5:
         cout << "tony stark";
         break;
   
       default:
         cout << "It's not 1 or 2";
         break;
     }
   }
   

   Producción:

   [Error] duplicate case value
   

8. Las etiquetas de los casos también deben ser constantes. De lo contrario, obtenemos un error de compilación.

   #include <iostream>
   using namespace std;
   
   int main() {
     int x = 2;
     int arr[] = {100, 200, 300};
     switch (x) {
       case arr[0]:
         cout << "Iron Man";
         break;
   
       case arr[1]:
         cout << "tony stark";
         break;
   
       case arr[2]:
         cout << "It's not 1 or 2";
         break;
     }
   }
   

   Producción:

   [Error] the value of 'arr' is not usable in a constant expression
   

9. Podemos agrupar todas las sentencias case realizando la misma tarea.

   #include <iostream>
   using namespace std;
   
   int main() {
     char x = 'A';
   
     switch (x) {
       case 'a':
       case 'e':
       case 'i':
       case 'o':
       case 'u':
       case 'A':
       case 'E':
       case 'I':
       case 'O':
       case 'U':
         cout << "Vowel";
         break;
   
       default:
         cout << "consonant";
     }
   }
   

Diferencia entre declaraciones switch y declaraciones if-else en C++

Cuando tenemos muchas sentencias if-else, el compilador debe verificarlas todas hasta encontrar una coincidencia válida. Mientras que en switch-case las declaraciones se usan si solo queremos que se ejecute un determinado bloque de código, si se cumple una determinada condición.

El siguiente ejemplo comprueba un carácter si es un alfabeto o no.

Código de ejemplo:

char x = '+';

if (x == 'A')
....

    else if (x == 'B')...

    else if (x == 'C')...

    ....else cout
    << "Not an alphabet"

Dado que + no es un alfabeto, lleva mucho más tiempo llegar al último porque primero debe examinar todas las condiciones anteriores. Si se implementa utilizando switch-case, utiliza una tabla de búsqueda o una lista hash cuando el número de casos/condiciones es muy grande.

Esto significa que todos los elementos obtienen el mismo tiempo de acceso. Entonces, cuando tenemos muchos casos/condiciones, se prefiere el switch sobre el if-else ya que es más rápido.