L’istruzione switch ci consente di modificare il flusso del programma in base ai valori (finiti) che può assumere una variabile.

La sintassi è questa:

switch (variabile)
{
        case valore1:
               // esegue le istruzioni in base al valore del primo case
        break;
        case valore2:
              // esegue le istruzioni in base al valore del secondo case
        break;
        ......... 
       case valore n:
             // esegue le istruzioni in base al valore del ennesimo case
       break;
       default:
            // esegue le istruzioni se non c’è corrispondenza  con alcun case 
       break;
}

La scelta del costrutto case da eseguire, non è dettato da una condizione come nell’istruzione if ma da un discriminante rappresentato dal valore che assume la variabile nel costrutto switch .

Qualora venisse rilevata una corrispondenza con il valore esplicito di un cotrutto case, verrà eseguito il codice relativo al suo interno.

Per rendere il concetto più semplice, facciamo ricorso al solito programmino che sicuramente ci farà capire molto più della teoria.

Scriviamo un programma che legge un numero intero da tastiera compreso, ad esempio, tra 1 e 5 e che ci stampi un messaggio.

N.R.

Codice sorgente SwitchNum.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37 

using System;
class SwitchNum
     {
         public static void Main()
           {
             // creo ed inizializzo una variabile di tipo byte
             byte num=0;
             // visualizzo un messaggio per l'utente
            Console.Write("Inserisci un numero tra 1-5: ");
            // leggo il numero da tastiera. Notate il casting
            num=Convert.ToByte(Console.ReadLine());
            // Istruzione switch
            switch (num)
             {
                case 1:
                         Console.WriteLine("\nHai digitato il numero 1");
                break;
                case 2:
                         Console.WriteLine("\nHai digitato il numero 2");
                break;
                case 3:
                         Console.WriteLine("\nHai digitato il numero 3");
                break;
                case 4:
                         Console.WriteLine("\nHai digitato il numero 4");
                break;
                case 5:
                         Console.WriteLine("\nHai digitato il numero 5");
                break;
               default:
                     // messaggio di default
                    Console.WriteLine("\nNon hai digitato un numero compreso
                     nell'intervallo");
                break;
               }
           }
     }

 

Nel listato non c’è molto da dire, però l’istruzione che compare alla riga numero 11 è degna di piccolo commento.

L’istruzione (metodo)

Console.ReadLine()

ci consente di leggere da tastiera del testo fino a quando non viene incontrato il carattere di fine linea (carriage return o line feed). Ebbene, alla richiesta di inserimento del numero, digiteremo soltanto un carattere (un numero tra 1 e 5) e successivamente, tramite il tasto invio, confermeremo tale richiesta.

Il carattere digitato però dovrà essere convertito (casting) in un tipo byte perché dovrà essere memorizzato in una variabile (num) di questo tipo.

L’istruzione (metodo)

Convert.ToByte(..)

esegue questa esplicita conversione affinchè la successiva istruzione switch possa manipolare il dato inserito.

Notate che l’istruzione switch è composta da cinque costrutti case più uno di default qualora si sia digitato un numero (carattere) non compreso nell’intervallo richesto.

Non vi resta che copiare il listato ed eseguirlo tramite la normale prassi.

Esecuzione di uno stesso blocco di codice per più di un case.

A volte si ha l’esigenza di far eseguire lo stesso blocco di codice per più clausole case. L’istruzione switch cambia così:

switch (variabile)
 {
          case valore1:
          case valore2:
          case valore3:
             // blocco di codice 123
          break;
          .........
          default:
            // esegue le istruzioni se non c’è  corrispondenza con alcun case 
          break;
  }

Il blocco di codice 123, verrà eseguito solo se il valore della variabile assumerà uno dei tre valori corrispondenti ai primi tre case.

Modifichiamo il codice del programma precedente in modo tale che ci notifichi se il numero da noi inserito è pari o dispari.

N.R.

Codice sorgente SwitchNum.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

 
 using System;
        class SwitchNum
            {
               public static void Main()
                 {
                   // creo ed inizializzo una variabile di tipo byte
                   byte num=0;
                   // visualizzo un messaggio per l'utente
                  Console.Write("Inserisci un numero tra 1-5: ");
                   // leggo il numero da tastiera. Notate il casting
                  num=Convert.ToByte(Console.ReadLine());
                  // Istruzione switch
                  switch (num)
                  {
                      case 1:
                      case 3:
                      case 5:
                               Console.WriteLine("\nIl numero è dispari");
                       break;

                     case 2:
                     case 4:
                              Console.WriteLine("\nIl numero è pari");
                       break;

                    default:
                           // messaggio di default
                      Console.WriteLine("\nNon hai digitato un numero compreso
                      nell'intervallo");
                    break;
                  }
               }
           }

Sono stati raggruppati, nell’istruzione switch, quei casi (case) in cui il numero inserito è dispari e quei casi in cui è pari. Compilate il listato e lanciatelo.

Un’ultima nota riguarda i tipi di dato che questa istruzione può gestire. Nella seguente tabella, sono riassunti i tipi di dato che si possono gestire:

sbyte

byte

short

ushort

int

uint

long

ulong

char

stringhe


Si conclude qui la trattazione di questa utile istruzione. Nella prossima lezione parleremo delle istruzioni iterative.

Pagina precedente - Pagina successiva