Construcția switch-case

Construcția switch-case permite compararea unei expresii cu un set de valori. Are următoarea formă:

switch (expresie)
{
    case valoare_1: instrucțiuni_1;
    case valoare_2: instrucțiuni_2;
    ...................
    case valoare_N: instrucțiuni_N;
     
    default: instrucțiuni;
}

După cuvântul-cheie switch, între paranteze urmează expresia care urmează să fie comparată. Valoarea acestei expresii este comparată secvențial cu valorile de după operatorii case. Iar dacă se găsește o potrivire, se execută blocul case corespunzător.

Trebuie menționat că expresia comparată în switch trebuie să fie de tip întreg, caracter sau enumerare (despre care vom vorbi mai târziu).

La finalul construcției switch poate apărea blocul default. Acesta este opțional și se execută în cazul în care valoarea expresiei de după switch nu corespunde niciunui case. De exemplu:

#include <iostream>
 
int main()
{
    int x {2};
      
    switch(x)
    {
        case 1: 
            std::cout << "x = 1" << "\n";
            break;
        case 2: 
            std::cout << "x = 2" << "\n";
            break;
        case 3: 
            std::cout << "x = 3" << "\n";
            break;
        default: 
            std::cout << "x is undefined" << "\n";
            break;
    }
}

Pentru a evita executarea blocurilor case/default următoare, la sfârșitul fiecărui bloc se plasează operatorul break. Adică, în acest caz, va fi executat operatorul:

case 2: 
    std::cout << "x = 2" << "\n";
    break;

După executarea operatorului break va avea loc ieșirea din construcția switch...case, iar ceilalți operatori case vor fi ignorați. Prin urmare, în consolă va fi afișată următoarea linie:

x = 2

Trebuie menționat cât de important este folosirea operatorului break. Dacă nu îl specificăm într-un bloc case, atunci după acel bloc execuția va continua cu următorul bloc case. De exemplu, să eliminăm toți operatorii break din exemplul anterior:

#include <iostream>
 
int main()
{
    int x {2};
      
    switch(x)
    {
        case 1: 
            std::cout << "x = 1" << "\n";
        case 2: 
            std::cout << "x = 2" << "\n";
        case 3: 
            std::cout << "x = 3" << "\n";
        default: 
            std::cout << "x is undefined" << "\n";
    }
}

În acest caz, se va executa din nou operatorul case 2:, deoarece variabila x = 2. Totuși, deoarece acest bloc case nu se termină cu un operator break, după finalizarea lui se vor executa și instrucțiunile din case 3:, chiar dacă valoarea variabilei x rămâne egală cu 2. În final, vom obține următorul output în consolă:

x = 2
x = 3
x is undefined

Combinarea condițiilor

Se poate specifica un singur set de instrucțiuni pentru mai multe etichete case:

#include <iostream>
  
int main()
{
    int x {2};
       
    switch(x)
    {
        case 1:
        case 2: 
            std::cout << "x = 1 or 2" << "\n";
            break;
        case 3: 
        case 4:
            std::cout << "x = 3 or 4" << "\n";
            break;
        case 5:
            std::cout << "x = 5" << "\n";
            break;
    }
}

Aici, dacă x = 1 sau x = 2, se execută aceeași instrucțiune std::cout << "x = 1 or 2" << "\n". În mod similar, pentru valorile x = 3 și x = 4 este definită o instrucțiune comună.

Variabile în blocurile case

Definirea variabilelor în blocurile case poate că nu este foarte frecventă, însă poate cauza dificultăți. Astfel, dacă o variabilă este definită într-un bloc case, atunci toate instrucțiunile acelui bloc trebuie plasate între acolade (pentru blocul default acest lucru nu este obligatoriu):

#include <iostream>
  
int main()
{
    int x {2};
       
    switch(x)
    {
        case 1:
        {
            int a{10};
            std::cout << a << std::endl;
            break;
        }
        case 2:
        {
            int b{20};
            std::cout << b << std::endl;
            break;
        }
        default:
            int c{30};
            std::cout << c << std::endl;
    }
}

Blocul switch cu inițializarea unei variabile

Uneori, în construcția switch, este necesar să definim o variabilă pentru diverse calcule intermediare. În acest scop, începând cu standardul C++17, limbajul C++ suportă o formă specială a construcției switch:

switch (inițializare; expresie) 
{
    // ..........
}

O astfel de formă acceptă de asemenea o expresie, a cărei valoare este comparată cu constantele de după operatorii case. Însă, înaintea expresiei, poate apărea și o definire și inițializare a unei variabile. De exemplu:

#include <iostream>
  
int main()
{
    char op = '+';
    int n = 10;
    switch(int k{2}; op)
    {
        case '+':
            std::cout << n + k << std::endl;
            break;
        case '-':
            std::cout << n - k << std::endl;
            break;
        case '*':
            std::cout << n * k << std::endl;
            break;
    }
}

În acest caz, în construcția switch este definită variabila k, care este disponibilă doar în cadrul acestei construcții switch. Ca expresie este folosită valoarea variabilei op, care reprezintă semnul operației. Și, în funcție de această valoare, se execută o anumită operație cu variabilele n și k.