Note Ingegneria Informatica · UniTN
Programmazione 1
Esercizi
in corso

Switch

Argomento di Programmazione 1. Fatto a lezione fra settembre e ottobre, deck 3.3: slide 16-31. Prima: Cicli for e do-while, che copre anche il resto del deck (break e continue nei cicli, Böhm-Jacopini). Base: Istruzioni condizionali.

Il filo del deck:

switch: selezione multipla        può sostituire una catena di if-else (slide 16)
   |
sintassi e default                espressione intera, case costanti (slide 17)
   |
esecuzione                        dal case uguale in giù, anche i blocchi dopo (slide 18-20)
   |
break                             per eseguire solo il proprio blocco (slide 21-23)
   |
esempio numero                    Q1 numero 3, Q2 numero -1 (slide 24-26)
   |
categorizzazione                  lo switch della slide 27, con le sue incongruenze
   |
conteggio cifre e spazi           switch dentro un ciclo di getchar (slide 28-30)
   |
osservazioni                      quando lo switch si può usare (slide 31)

1Definizioni

switch (slide 16). Struttura di selezione multipla: sceglie fra più strade in base al valore di un’espressione. Può sostituire una catena di if-else. Il prof dice che non è necessaria (tutto si fa con if-else, vedi Böhm-Jacopini in Cicli for e do-while) ma comoda in certe situazioni.

L’idea: una catena if (x <mark> 1) ... else if (x </mark> 2) ... else if (x <mark> 3) ... ripete x </mark> a ogni riga e nasconde il fatto che si sta guardando sempre la stessa variabile. Lo switch lo dice una volta sola, in testa, e poi elenca i casi come le voci di un menu.

Sintassi (slide 17).

switch (<espressione intera>) {
    case v1: { blocco istruzioni }
    case v2: { blocco istruzioni }
    ...
    default: { blocco istruzioni }
}

Esempio 1, valori validi: switch (n % 3) con case 0:, case 1:, case 2: (l’espressione è un calcolo intero qualsiasi); switch (c) con c di tipo char e case 'a':.

Esempio 2, valori non validi (non compilano, verificato con gcc): switch (x) con x di tipo float (switch quantity not an integer); case y: con y variabile (case label does not reduce to an integer constant); due volte case 1: (duplicate case value).

Esecuzione (slide 18-20). Si valuta l’espressione, poi la si confronta con v1, poi con v2, e così via. Al primo case uguale si entra, e da lì si eseguono il blocco di v1, poi quello di v2, e tutti i successivi fino alla fine dello switch. I case sono solo etichette di ingresso, non confini. Questo comportamento si chiama fall-through (caduta).

switch (espressione intera)
   |   si valuta una volta
   v
confronto con case v1, v2, ...   il primo uguale è il punto di ingresso
   |   nessuno uguale: default, se c'è; altrimenti niente
   v
esegue da lì in giù               anche i blocchi dei case dopo (fall-through)
   |
break                             esce dallo switch

L’immagine giusta è quella di una scala con dei pianerottoli numerati: il valore dice a quale pianerottolo entri, poi scendi tutti i gradini fino in fondo, a meno che un break ti faccia uscire.

La slide 20 chiude con la domanda: “E se volessi limitare l’esecuzione del blocco di istruzioni per ciascun valore v1, v2, etc.?”. La risposta è il break.

break nello switch (slide 21). Per eseguire solo il blocco del proprio case, lo si chiude con break, che restituisce il controllo all’istruzione dopo lo switch. Il break è opzionale: toglierlo è il modo di far proseguire l’esecuzione nel blocco dopo.

switch (<espressione intera>) {
    case v1: { blocco istruzioni } break;
    case v2: { blocco istruzioni } break;
    ...
    default: { blocco istruzioni } break;
}

Il break dopo default, se default è l’ultimo, non cambia niente; si mette per abitudine, così aggiungere un case dopo non introduce una caduta.

Differenze con l’if-else (slide 31). Lo switch si usa solo quando:

Condizioni come x>10x > 10, a<ba < b o “fra 18 e 30” non si scrivono con un case: servono gli if.

2Concetti

2.1Flowchart con e senza break

(slide 22-23) Con il break ogni blocco, finito, va diretto all’uscita: è una catena di if-else if. Senza il break dopo il blocco 1 (la freccia rossa “tolto break” della slide 23), chi entra da val1 esegue il blocco 1 e poi anche il blocco 2, senza rifare il confronto con val2.

con break                         senza break dopo il blocco 1
exp==val1 ? -> blocco 1 -> fine   exp==val1 ? -> blocco 1 -> blocco 2 -> fine
exp==val2 ? -> blocco 2 -> fine   exp==val2 ? -------------> blocco 2 -> fine
...                               ...
default     -> blocco d -> fine   default     -> blocco d -> fine

2.2Più valori sullo stesso blocco

Il fall-through serve: case vuoti scritti uno sotto l’altro portano tutti allo stesso blocco.

case 3:
case 4:
case 5:
    printf("Valore positivo piccolo");
    break;

Si entra da 3, 4 o 5 e si arriva comunque al printf. È il modo di esprimere “3 o 4 o 5”, visto che un case non accetta intervalli. Un case vuoto non dà warning; un case che fa qualcosa e poi cade nel successivo sì (-Wimplicit-fallthrough, attivo con -Wextra). Quando la caduta è voluta si scrive il commento /* fall through */ prima del case successivo: gcc lo riconosce e chi legge capisce che non è una dimenticanza.

Esempio 1, giorni della settimana, con il weekend raggruppato e il default per i valori non validi:

#include <stdio.h>

int main(void)
{
    int g;

    for (g = 0; g <= 8; g += 4) {
        switch (g) {
        case 1:
            printf("lunedi\n");
            break;
        case 2:
            printf("martedi\n");
            break;
        case 3:
            printf("mercoledi\n");
            break;
        case 4:
            printf("giovedi\n");
            break;
        case 5:
            printf("venerdi\n");
            break;
        case 6:
        case 7:
            printf("weekend\n");
            break;
        default:
            printf("%d non e' un giorno\n", g);
            break;
        }
    }
    return 0;
}
gcase che corrispondeoutput
0nessuno: default0 non e' un giorno
4case 4giovedi, poi break
8nessuno: default8 non e' un giorno

(verificato) Con g = 6 o g = 7 si entrerebbe da due etichette diverse nello stesso printf("weekend\n").

Esempio 2, quanti giorni ha un mese. Tre gruppi, e uno dei casi ha dentro un if: lo switch sceglie il mese, ma non sa confrontare l’anno.

#include <stdio.h>

int main(void)
{
    int mese;
    int anno;
    int giorni;

    if (scanf("%d %d", &mese, &anno) != 2) {
        return 1;
    }
    switch (mese) {
    case 4:
    case 6:
    case 9:
    case 11:
        giorni = 30;
        break;
    case 2:
        if ((anno % 4 == 0 && anno % 100 != 0) || anno % 400 == 0) {
            giorni = 29;
        } else {
            giorni = 28;
        }
        break;
    case 1:
    case 3:
    case 5:
    case 7:
    case 8:
    case 10:
    case 12:
        giorni = 31;
        break;
    default:
        giorni = 0;
        break;
    }
    if (giorni == 0) {
        printf("mese non valido\n");
    } else {
        printf("%d/%d ha %d giorni\n", mese, anno, giorni);
    }
    return 0;
}
inputpercorsooutput
4 2026case 4, cade su giorni = 30, break4/2026 ha 30 giorni
2 2024case 2, bisestile (per 4, non per 100)2/2024 ha 29 giorni
2 1900case 2, per 100 ma non per 4002/1900 ha 28 giorni
12 2026case 12, ultimo del gruppo da 3112/2026 ha 31 giorni
13 2026defaultmese non valido

(verificati) L’ordine dei case è libero: qui i mesi da 31 stanno dopo il febbraio, e lo switch funziona lo stesso perché cerca il valore uguale, non va in ordine numerico. Il regolamento dei bisestili è quello di Istruzioni condizionali (esercizi), esercizio 8.

2.3Fall-through voluto

A volte la caduta è proprio quello che serve: ogni caso fa la sua parte e quella di tutti i casi sotto. Esempio, un conto alla rovescia che parte dal numero dato:

#include <stdio.h>

int main(void)
{
    int n;

    for (n = 3; n >= 0; n--) {
        printf("n=%d:", n);
        switch (n) {
        case 3:
            printf(" tre");
            /* fall through */
        case 2:
            printf(" due");
            /* fall through */
        case 1:
            printf(" uno");
            /* fall through */
        default:
            printf(" via!\n");
        }
    }
    return 0;
}

Output (verificato):

n=3: tre due uno via!
n=2: due uno via!
n=1: uno via!
n=0: via!

Con n = 3 si entra in cima e si scende fino in fondo; con n = 1 si entra al terzo pianerottolo. Con n = 0 nessun case: si va al default, che è anche l’ultimo blocco. Senza i commenti /* fall through */ il programma fa lo stesso, ma gcc con -Wextra avvisa tre volte this statement may fall through.

2.4switch dentro un ciclo

break dentro uno switch esce dallo switch, non dal ciclo che lo contiene: il ciclo va avanti con il giro successivo. Per uscire dal ciclo da dentro uno switch serve una variabile di controllo nella condizione del ciclo. continue invece, anche se scritto dentro lo switch, agisce sul ciclo.

Esempio 1, il break non ferma il while:

#include <stdio.h>

int main(void)
{
    int i = 0;

    while (i < 4) {
        switch (i) {
        case 2:
            printf("break nello switch, ");
            break;
        default:
            printf("i=%d, ", i);
            break;
        }
        printf("dopo lo switch\n");
        i++;
    }
    printf("fuori dal while, i=%d\n", i);
    return 0;
}

Output (verificato):

i=0, dopo lo switch
i=1, dopo lo switch
break nello switch, dopo lo switch
i=3, dopo lo switch
fuori dal while, i=4

Con i = 2 il break porta subito dopo la } dello switch: si stampa dopo lo switch e il while continua.

Esempio 2, il menu: do-while perché il menu va mostrato almeno una volta, switch per la scelta, una variabile fine per uscire dal ciclo (il break del case 0 da solo non basterebbe).

#include <stdio.h>

int main(void)
{
    int scelta;
    int saldo = 100;
    int fine = 0;

    do {
        printf("1) deposita 50  2) preleva 30  3) saldo  0) esci: ");
        if (scanf("%d", &scelta) != 1) {
            return 1;
        }
        switch (scelta) {
        case 1:
            saldo += 50;
            break;
        case 2:
            if (saldo >= 30) {
                saldo -= 30;
            } else {
                printf("saldo insufficiente\n");
            }
            break;
        case 3:
            printf("saldo=%d\n", saldo);
            break;
        case 0:
            fine = 1;
            break;
        default:
            printf("scelta non valida\n");
            break;
        }
    } while (!fine);
    printf("ciao, saldo finale %d\n", saldo);
    return 0;
}

Con le scelte 3 2 2 2 2 9 1 3 0:

sceltacasesaldostampa (oltre al menu)
3case 3100saldo=100
2case 270
2case 240
2case 210
2case 2, 10 >= 30 falso10saldo insufficiente
9default10scelta non valida
1case 160
3case 360saldo=60
0case 0: fine = 160

Poi !fine vale 0, il do-while esce e stampa ciao, saldo finale 60 (verificato). È lo schema del menu della prova al calcolatore.

3Metodo

Tracciare uno switch.

  1. Calcola il valore dell’espressione.
  2. Scorri i case e trova quello uguale, ovunque sia (anche dopo il default). Se non c’è, vai a default, ovunque sia scritto; se non c’è nemmeno quello, lo switch non fa niente.
  3. Da lì esegui tutto verso il basso, ignorando le etichette case e default che incontri.
  4. Fermati al primo break o alla } di chiusura.
  5. Se lo switch è in un ciclo, una riga della tabella per giro: valore, etichetta di ingresso, blocchi eseguiti, variabili dopo.

Scrivere uno switch.

  1. Controlla che la scelta dipenda da un solo valore intero o carattere. Se ci sono intervalli larghi o confronti, usa gli if.
  2. Un case per valore, con i valori dello stesso gruppo uno sotto l’altro.
  3. break alla fine di ogni gruppo, default per tutto il resto, anche solo per segnalare un input non valido.

Da switch a if-else. Ogni gruppo di case diventa una condizione con ||: case 3: case 4: case 5: diventa if (x <mark> 3 || x </mark> 4 || x == 5), default diventa l’else finale. Con un fall-through fra due gruppi il blocco del primo va ripetuto in testa al secondo.

Da if-else a switch. Si può solo se ogni condizione è un’uguaglianza == sulla stessa variabile intera (o un || di uguaglianze). Ogni uguaglianza diventa un case, ogni ramo finisce con break, l’else finale diventa default.

4Esempi svolti a lezione

4.1Lo switch su numero

(slide 24-26) La slide mostra lo switch su una variabile intera numero (“in questo caso l’espressione è costituita dal solo identificatore della variabile”) e fa due domande. Sulla slide printf(”Invalido") apre la stringa con una virgoletta tipografica: non compila. Versione completa e corretta, con \n in ogni stampa:

#include <stdio.h>

int main(void)
{
    int numero;

    if (scanf("%d", &numero) != 1) {
        return 1;
    }
    switch (numero) {
    case 0:
        printf("Nessuno\n");
        break;
    case 1:
        printf("Uno\n");
        break;
    case 2:
        printf("Due\n");
        break;
    case 3:
    case 4:
    case 5:
        printf("Valore positivo piccolo\n");
        break;
    default:
        printf("Invalido\n");
        break;
    }
    return 0;
}
numerooutput
0Nessuno
1Uno
3, 4, 5Valore positivo piccolo
6Invalido
-1Invalido

(verificati)

Q1: cosa succede se numero vale 3? Si entra da case 3:, che è vuoto, si cade in case 4: e case 5:, anch’essi vuoti, e si arriva al printf: stampa Valore positivo piccolo, poi il break esce.

Q2: e se vale -1? Nessun case corrisponde: si esegue default e stampa Invalido. Lo stesso per 6 o per 1000.

4.2Lettura e categorizzazione di un numero

(slide 27) Il programma della slide legge un “numero piccolo intero positivo” e lo classifica. I commenti della slide dicono: 0 dà “Zero”, 1 dà “Uno”, da 1 a 3 “piccolo”, 4, 5 e oltre “grande”. Il codice non fa questo, ed è un ottimo esercizio di tracing. Codice della slide, con il controllo di scanf e il commento /* fall through */ che rende esplicita la caduta (senza, gcc con -Wextra avvisa this statement may fall through):

#include <stdio.h>

int main(void)
{
    int Valore;

    printf("Inserisci numero piccolo intero positivo\n");
    if (scanf("%d", &Valore) != 1) {
        return 1;
    }
    switch (Valore) {
    case 0: printf("Zero\n"); break;
    case 1: printf("Uno\n");
        /* fall through */
    case 2:
    case 3: printf("Piccolo\n"); break;
    case 4:
    case 5:
    default: printf("Invalido\n");
    }
    return 0;
}

Cosa stampa davvero, dopo la richiesta (verificato):

Valoreingressoblocchi eseguitioutput
0case 0printf("Zero\n"), breakZero
1case 1printf("Uno\n"), nessun break: cade in case 2 (vuoto), case 3: printf("Piccolo\n"), breakUno poi Piccolo
2case 2vuoto, cade in case 3: Piccolo, breakPiccolo
3case 3Piccolo, breakPiccolo
4, 5case 4 o case 5vuoti, cadono nel defaultInvalido
9, -1nessun case: defaultInvalido

Le incongruenze della slide, da segnalare all’esame se chiedono “trova l’errore”:

4.3Conteggio di cifre, spazi e altri caratteri

(slide 28-30) Il testo: dalla sequenza di caratteri in standard input, terminata da EOF, contare

La slide 29 suggerisce di partire dal ciclo di copia con getchar di Input e output di caratteri (while ((c = getchar()) != EOF) putchar(c);) e aggiungere i contatori e lo switch. Soluzione della slide 30, con una dichiarazione per riga (nella soluzione il contatore degli spazi si chiama nwhite e quello degli altri nother, e c’è una int i mai usata):

#include <stdio.h>

int main(void)
{
    int c;
    int nwhite = 0;
    int nother = 0;
    int n02 = 0;
    int n35 = 0;
    int n69 = 0;

    while ((c = getchar()) != EOF) {
        switch (c) {
        case '0': case '1': case '2':
            n02++;
            break;
        case '3': case '4': case '5':
            n35++;
            break;
        case '6': case '7': case '8': case '9':
            n69++;
            break;
        case ' ': case '\t': case '\n':
            nwhite++;
            break;
        default:
            nother++;
            break;
        }
    }
    printf("\n---------------\n");
    printf("Gravi Insufficienze=%d\n", n02);
    printf("Insufficienze=%d\n", n35);
    printf("Sufficienze=%d\n", n69);
    printf("white space=%d\n", nwhite);
    printf("other=%d\n", nother);
    return 0;
}

Con l’input della slide, 02a 3A seguito subito da EOF (nessun invio dopo la A):

caratterecasecontatore
0'0'n02 = 1
2'2'n02 = 2
adefaultnother = 1
spazio' 'nwhite = 1
3'3'n35 = 1
Adefaultnother = 2

Output (verificato):


---------------
Gravi Insufficienze=2
Insufficienze=1
Sufficienze=0
white space=1
other=2

Corrisponde ai valori attesi della slide 28 (n02=2, n35=1, n69=0, ns=1, no=2). Se l’input si scrive da tastiera e si preme invio prima di EOF, l’a capo è un carattere in più e white space diventa 2.

Perché funziona: c è un int ma contiene il codice ASCII del carattere, e '0', '\t' sono costanti intere (48, 9). Lo switch confronta numeri. I case sullo stesso rigo sono la stessa cosa dei case uno sotto l’altro. Il break qui esce solo dallo switch: il while prosegue con il carattere successivo.

Variante sullo stesso schema, contare le vocali (maiuscole e minuscole) e le altre lettere, ignorando spazi e a capo:

#include <stdio.h>

int main(void)
{
    int c;
    int vocali = 0;
    int altre = 0;

    while ((c = getchar()) != EOF) {
        switch (c) {
        case 'a': case 'e': case 'i': case 'o': case 'u':
        case 'A': case 'E': case 'I': case 'O': case 'U':
            vocali++;
            break;
        case ' ':
        case '\n':
            break;
        default:
            altre++;
            break;
        }
    }
    printf("vocali=%d altre=%d\n", vocali, altre);
    return 0;
}

Con input Ciao a tutti (senza invio) le vocali sono i a o a u i, le altre C t t t: stampa vocali=6 altre=4 (verificato). Il case ' ': case '\n': break; ha un blocco fatto solo di break: serve a non far finire spazi e a capo nel default.

5Esercizi tipo esame

In una pagina a parte, dal più facile al livello del 30: Switch (esercizi).

6Errori tipici

7Domande