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 }
}
- L’espressione deve avere valore intero (tipo integral, slide 31):
int, ma anchechar, che in C è un piccolo intero. Nonfloat, non stringhe. v1,v2, … sono costanti intere:3,'a','\n'. Non variabili e non intervalli.- Ogni valore compare in un solo
case. defaultè opzionale: si esegue quando nessuncasecorrisponde. Se manca e nessuncasecorrisponde, loswitchnon fa niente.
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:
- tutte le scelte dipendono dal valore di una sola espressione, valutata una volta;
- il valore è di tipo intero;
- ogni scelta corrisponde a valori singoli, e
defaultraccoglie tutti gli altri.
Condizioni come , 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;
}
g | case che corrisponde | output |
|---|---|---|
| 0 | nessuno: default | 0 non e' un giorno |
| 4 | case 4 | giovedi, poi break |
| 8 | nessuno: default | 8 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;
}
| input | percorso | output |
|---|---|---|
4 2026 | case 4, cade su giorni = 30, break | 4/2026 ha 30 giorni |
2 2024 | case 2, bisestile (per 4, non per 100) | 2/2024 ha 29 giorni |
2 1900 | case 2, per 100 ma non per 400 | 2/1900 ha 28 giorni |
12 2026 | case 12, ultimo del gruppo da 31 | 12/2026 ha 31 giorni |
13 2026 | default | mese 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:
| scelta | case | saldo | stampa (oltre al menu) |
|---|---|---|---|
| 3 | case 3 | 100 | saldo=100 |
| 2 | case 2 | 70 | |
| 2 | case 2 | 40 | |
| 2 | case 2 | 10 | |
| 2 | case 2, 10 >= 30 falso | 10 | saldo insufficiente |
| 9 | default | 10 | scelta non valida |
| 1 | case 1 | 60 | |
| 3 | case 3 | 60 | saldo=60 |
| 0 | case 0: fine = 1 | 60 |
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.
- Calcola il valore dell’espressione.
- Scorri i
casee trova quello uguale, ovunque sia (anche dopo ildefault). Se non c’è, vai adefault, ovunque sia scritto; se non c’è nemmeno quello, loswitchnon fa niente. - Da lì esegui tutto verso il basso, ignorando le etichette
caseedefaultche incontri. - Fermati al primo
breako alla}di chiusura. - Se lo
switchè in un ciclo, una riga della tabella per giro: valore, etichetta di ingresso, blocchi eseguiti, variabili dopo.
Scrivere uno switch.
- Controlla che la scelta dipenda da un solo valore intero o carattere. Se ci sono intervalli larghi o confronti, usa gli
if. - Un
caseper valore, con i valori dello stesso gruppo uno sotto l’altro. breakalla fine di ogni gruppo,defaultper 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;
}
numero | output |
|---|---|
| 0 | Nessuno |
| 1 | Uno |
| 3, 4, 5 | Valore positivo piccolo |
| 6 | Invalido |
| -1 | Invalido |
(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):
Valore | ingresso | blocchi eseguiti | output |
|---|---|---|---|
| 0 | case 0 | printf("Zero\n"), break | Zero |
| 1 | case 1 | printf("Uno\n"), nessun break: cade in case 2 (vuoto), case 3: printf("Piccolo\n"), break | Uno poi Piccolo |
| 2 | case 2 | vuoto, cade in case 3: Piccolo, break | Piccolo |
| 3 | case 3 | Piccolo, break | Piccolo |
| 4, 5 | case 4 o case 5 | vuoti, cadono nel default | Invalido |
| 9, -1 | nessun case: default | Invalido |
Le incongruenze della slide, da segnalare all’esame se chiedono “trova l’errore”:
- per 1 stampa due righe, perché manca il
breakdopoprintf("Uno\n"); - il commento promette “grande” per 4, 5 e oltre, ma non c’è nessun
printf("Grande"): icase 4ecase 5vuoti portano aldefault, che stampa “Invalido”; case 4:ecase 5:prima deldefaultsono inutili: senza di loro 4 e 5 andrebbero comunque aldefault;- il commento su
case 2:(“corpo istruzioni vuote: uso ; è ridondante ma permesso”) si riferisce al fatto che uncasepuò non avere istruzioni.
4.3Conteggio di cifre, spazi e altri caratteri
(slide 28-30) Il testo: dalla sequenza di caratteri in standard input, terminata da EOF, contare
n02: cifre 0, 1, 2 (gravi insufficienze);n35: cifre 3, 4, 5 (insufficienze);n69: cifre 6, 7, 8, 9 (sufficienze);ns: spazi, cioè' ','\t','\n';no: tutto il resto.
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):
| carattere | case | contatore |
|---|---|---|
0 | '0' | n02 = 1 |
2 | '2' | n02 = 2 |
a | default | nother = 1 |
| spazio | ' ' | nwhite = 1 |
3 | '3' | n35 = 1 |
A | default | nother = 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
- Dimenticare il
break: l’esecuzione cade nelcasesuccessivo (il caso 1 della slide 27). - Pensare che
case 4: case 5:vuoti prima deldefaultfacciano qualcosa di diverso daldefault. - Credere che lo
switchprovi icasein ordine numerico, o che ildefaultdebba stare in fondo: si entra dall’etichetta uguale ovunque sia, e undefaultin mezzo cade neicasesotto di lui. - Usare uno
switchsu unfloat, su una stringa o con uncasevariabile: non compila. - Cercare di scrivere un intervallo in un
case(case 1..5,case x > 3): non esiste in C standard, si elencano i valori o si usa unif. - Scrivere
case 1:quando si legge un carattere: il carattere'1'vale 49, non 1. - Credere che
breakdentro unoswitchdentro un ciclo esca dal ciclo: esce solo dalloswitch. - Virgolette tipografiche copiate dalle slide (
”Invalido"): non sono"e il programma non compila.
7Domande
-
Di che tipo deve essere l’espressione di uno
switch? E i valori deicase? -
Come si esegue uno
switch? Cosa succede dopo il blocco delcasescelto, se manca ilbreak? -
Cosa fa
default, ed è obbligatorio? -
Come si fa a eseguire lo stesso blocco per i valori 3, 4 e 5?
-
Nell’esempio della slide 24, cosa stampa lo
switchsenumerovale 3? E se vale -1? -
Cosa stampa lo
switchdella slide 27 conValoreuguale a 1? E con 4? -
In quali casi uno
switchnon può sostituire una catena diif-else? -
Un
breakdentro unoswitchdentro unwhile: da cosa esce? -
Perché nello
switchsui caratteri letti congetcharsi scrivecase '1':e noncase 1:? -
Se il
defaultè scritto in mezzo aicasee non habreak, cosa succede quando nessuncasecorrisponde? -
Come esci da un ciclo
do-whiledi menu quando la scelta “esci” sta in uncasedelloswitch? -
Quando un fall-through è voluto, come lo segnali a gcc e a chi legge?