La scelta multipla: costrutto switch-case

Può essere necessario, nel corso di un programma, variare l’elaborazione in seguito a più condizioni. Potrebbero essere, per esempio, i diversi valori che può assumere una variabile. Esiste nel linguaggio C++ un costrutto per codificare la scelta multipla. Sintatticamente la struttura si presenta in questo modo:

switch(espressione)
case valore:
  istruzione
case valore:
  istruzione
  ...
default:
  istruzione

Nelle varie istruzioni case si elencano i valori che può assumere espressione e che interessano per l’elaborazione. Valutata l’espressione specificata, se il valore non coincide con alcuno di quelli specificati, viene eseguita l’istruzione compresa nella clausola default. Occorre tenere presente che, la differenza sostanziale rispetto ad una struttura if, consiste nel fatto che, nella if, le varie strade sono alternative. I vari case esistenti agiscono invece da etichette: se espressione assume un valore specificato in un case, vengono eseguite le istruzioni da quel punto in poi. Il valore specificato in case, in definitiva, assume funzione di punto di ingresso nella struttura.

Se si vuole delimitare l’istruzione da eseguire a quella specificata nella case che verifica il valore cercato, occorre inserire l’istruzione break che fa proseguire l’elaborazione dall’istruzione successiva alla chiusura della struttura.

Per chiarire meglio il funzionamento della struttura viene presentato un programma che effettua il conteggio delle parentesi di una espressione algebrica.

// Conta i vari tipi di parentesi contenute in una espressione 
// algebrica (non fa distinzione fra parentesi aperte e chiuse)

#include <iostream>
#include <string>
using namespace std;

int main()
{
  string espress;     
  int pargraf,parquad,partond;
  int i;

   // acquisizione espressione come stringa

  cout << "\nEspressione algebrica ";
  getline(cin,espress);
  
 // ricerca parentesi nella espressione

  pargraf=parquad=partond=0;
  for(i=0;i<espress.length();i++) {  	/*1*/     

    switch(espress.at(i)) {	/*2*/
    case '{':; case '}':   	/*3*/                     
      pargraf++;
      break;        	/*4*/                          
    case '[':; case ']':                      	/*3*/
      parquad++;
      break;                                  	/*4*/
    case '(':; case ')':        	/*3*/              
      partond++;
      break;	/*4*/
    }
  }

  // presentazione dei risultati

  cout << "\nGraffe = " << pargraf << endl; 
  cout << "Quadre = " << parquad << endl;
  cout << "Tonde  = " << partond << endl;

  return 0;
}

Il ciclo che comincia da 1 si occupa di effettuare una scansione lineare della stringa: verranno esaminati tutti i caratteri che la compongono. La stringa è trattata come un vettore di caratteri e se ne può conoscere la lunghezza applicando il metodo length() alla stringa da elaborare, quindi il ciclo deve contare (la variabile i) da 0 (la posizione del primo carattere della stringa) fino al numero che indica la quantità di caratteri che la compongono, estremo escluso, perché il conteggio parte dal valore 0.

Nella riga con etichetta 2 viene specificata l’espressione da valutare: espress.at(i) cioè il carattere che si trova nel posto i dell’espressione algebrica.

Nelle righe con etichetta 3 si esaminano i casi parentesi aperta o parentesi chiusa. I singoli valori sono seguiti dalla istruzione nulla (il solo carattere ;) e, poiché l’elaborazione continua da quel punto in poi, sia che si tratti di parentesi aperta che di parentesi chiusa si arriva all’aggiornamento del rispettivo contatore.

Nelle righe con etichetta 4 si blocca l’esecuzione del programma altrimenti, per esempio, una parentesi graffa oltre che come graffa verrebbe conteggiata anche come quadra e tonda, una parentesi quadra verrebbe conteggiata anche come tonda. Si noti che, anche se sono presenti due istruzioni, non vengono utilizzate parentesi per delimitare il blocco: il funzionamento della switch-case prevede infatti la continuazione dell’elaborazione con l’istruzione successiva. L’ultima istruzione break è inserita solo per coerenza con gli altri casi. Inoltre se in seguito si dovesse aggiungere una istruzione default, il programma continuerebbe a dare risultati coerenti senza necessità di interventi se non nella parte da inserire.