Note Ingegneria Informatica · UniTN
Programmazione 1
Esercizi
Lezione
set, giorno?
in corso

Istruzioni condizionali

Argomento di Programmazione 1. Fatto a lezione a settembre, prima parte del deck 3.2: slide 1-39. Prima: Algebra di Boole. Dopo: Ciclo while ed esempi.

Il filo del deck:

tre strutture          assegnazione, condizionale, iterativa
     |
if / if-else           flowchart, semantica, esempi
     |
ambiguità              dangling else: l'else va all'ultimo if
     |
?:                     l'if-else dentro un'espressione
     |
blocco { }             più istruzioni valgono come una
     |
precedenze             come si legge  a + b - 4 <= 9 && x < tot - 1
     |
trappole               graffe mancanti, esercizi 1a e 1b

1Definizioni

Le istruzioni del C (slide 4-6). Con tre strutture sintattiche si scrive qualunque programma, le stesse viste in pseudocodice in Introduzione al corso e algoritmi:

Finora un programma era una sequenza: le istruzioni si eseguivano tutte, una dopo l’altra, sempre nello stesso ordine. Con la condizionale il programma sceglie: alcune righe vengono saltate a seconda dei dati.

Il deck si apre con un problema, un analizzatore di testo che sostituisce una parola con un’altra (slide 3): con input zapa$zappa#zapa cosa zata zapa zorro zapa zapa% deve stampare zappa cosa zata zappa zorro zappa zappa. Serve tutto questo capitolo (e i cicli) per arrivarci, e le slide non lo risolvono ancora.

if (slide 7-9). Si usa quando un blocco di istruzioni va eseguito soltanto se una condizione è vera, e se è falsa non si deve fare niente.

if (espressione) istruzione

if-else (slide 10-12). Si usa quando c’è un blocco per il caso vero e un altro blocco, in alternativa, per il caso falso.

if (espressione) istruzione1 else istruzione2
ifif-else

A parole: l’if è una deviazione facoltativa (o entri nel riquadro o tiri dritto), l’if-else è un bivio (prendi una delle due strade, poi le strade si riuniscono). In tutti e due i casi dopo il costrutto si prosegue con l’istruzione successiva.

Quando una condizione è vera. Nel rombo del flowchart della slide c’è scritto “Espressione ≠ 0 ?”: in C la condizione è un’espressione qualsiasi, ed è vera se il suo valore è diverso da zero, falsa se vale zero. if (x) equivale a if (x != 0), e if (!x) a if (x <mark> 0). I confronti (>, a </mark> b, &&…) producono l’intero 1 se veri e 0 se falsi, come in Espressioni, operatori e costanti.

Il perché: il C è nato senza un tipo booleano e rappresenta vero e falso con gli interi. Ogni numero diverso da zero, anche negativo, vale vero.

Esempio 1, condizioni che non sono confronti:

#include <stdio.h>

int main(void)
{
    int x = 5;
    int y = 0;

    if (x) printf("x vero\n");
    if (y) printf("y vero\n"); else printf("y falso\n");
    if (x - 5) printf("x - 5 vero\n"); else printf("x - 5 falso\n");
    if (-3) printf("-3 vero\n");
    printf("%d %d\n", x > 2, y > 2);
    return 0;
}

Output (verificato):

x vero
y falso
x - 5 falso
-3 vero
1 0

x - 5 vale 0, quindi è falsa; -3 è diverso da zero, quindi è vera. L’ultima riga mostra che un confronto vale proprio 1 o 0.

Esempio 2, pari e dispari con %. n % 2 vale 1 per i dispari positivi e 0 per i pari, quindi si può usare direttamente come condizione “è dispari”:

#include <stdio.h>

int main(void)
{
    int n = 7;

    if (n % 2) printf("%d dispari\n", n); else printf("%d pari\n", n);
    n = 10;
    if (n % 2) printf("%d dispari\n", n); else printf("%d pari\n", n);
    if (!(n % 5)) printf("%d multiplo di 5\n", n);
    return 0;
}

Output (verificato): 7 dispari, 10 pari, 10 multiplo di 5. Nell’ultima 10 % 5 vale 0, !0 vale 1: vera. Le parentesi attorno a n % 5 servono, perché ! lega più di % (sotto, Precedenze).

Controesempio, l’assegnazione x = 0 al posto del confronto x == 0:

int x = 5;
if (x = 0) printf("zero\n"); else printf("non zero\n");
printf("x=%d\n", x);

Stampa non zero e poi x=0. x = 0 è un’assegnazione: mette 0 in x e vale 0, quindi la condizione è sempre falsa e in più il valore di x è perso. gcc con -Wall avvisa: suggest parentheses around assignment used as truth value (verificato).

Semantica (slide 13).

  1. Si valuta la condizione.
  2. Se è VERA si esegue solamente la prima istruzione (o sequenza).
  3. Se è FALSA si esegue la seconda, quella dopo else.
  4. Se manca l’else e la condizione è falsa, si prosegue con l’istruzione che segue l’if.

In ogni caso uno solo dei due rami viene eseguito, mai entrambi, e la condizione si valuta una volta sola.

Istruzione composta, o blocco (slide 25-27). Più istruzioni in sequenza racchiuse fra { e } formano un blocco “del tutto equivalente a una singola istruzione”. Il corpo di main è un blocco. Dopo } non serve il ;, perché la graffa fa già da delimitatore. Se lo aggiungi di solito non viene segnalato errore: è un’istruzione vuota. C’è un caso in cui lo diventa, ed è fra } ed else (sotto, Errori tipici).

Serve perché la sintassi di if prevede una istruzione per ramo. Se nel ramo ne vuoi due, le metti in un blocco: per l’if il blocco intero conta come una.

if (a > b) { max = a; printf("%d", a); }    il blocco è il ramo: o tutte e due o nessuna
if (a > b) max = a; printf("%d", a);        il ramo è solo max = a; il printf viene sempre

Operatore ternario ?: (slide 21-22). Forma sintetica dell’if-else, ed è l’unico operatore del C con tre operandi.

espressione1 ? espressione2 : espressione3

Si valuta espressione1: se è vera il risultato è il valore di espressione2, altrimenti quello di espressione3. Viene valutata solo una delle due.

La slide lo presenta come equivalente a if (e1) {e2;} else {e3;}. La differenza che conta: ?: è un’espressione, quindi ha un valore e si può mettere a destra di un’assegnazione o dentro un printf. L’if è un’istruzione e non ha valore. Per questo si usa per inizializzare:

int opening_time = (day == WEEKEND) ? 12 : 9;

L’if serve a scegliere cosa fare, ?: a scegliere quale valore usare.

Ambiguità del dangling else (slide 18-20). Come la frase “Carlo discute della relazione con Roberta”, che ha due letture (Carlo discute [della relazione con Roberta], oppure Carlo discute [della relazione] [con Roberta]), questa riga ne ha due:

if (C1) if (C2) S1; else S2;

a)  if (C1)                    b)  if (C1)
        if (C2) S1;                    if (C2) S1;
    else S2;                           else S2;

Convenzione del C: il ramo else viene attribuito all’ultimo if rimasto senza else, cioè il più vicino. Vale la lettura b, qualunque sia l’indentazione. Per avere la a servono le graffe:

if (C1) {if (C2) S1;} else S2;

La differenza si vede quando C1 è falsa: con la lettura b non si esegue niente, con la a si esegue S2. Con C1 vera e C2 falsa cambia di nuovo: la b esegue S2, la a niente. Coincidono solo quando sono vere tutte e due (S1). gcc con -Wall avvisa: suggest explicit braces to avoid ambiguous 'else' (verificato).

2Concetti

2.1if annidati e catena else if

Un ramo di un if è un’istruzione qualsiasi, quindi può essere un altro if. Messo nel ramo else, dà la catena che sceglie fra più di due casi:

if (c1)
    S1
else if (c2)
    S2
else
    S3

Non è un costrutto nuovo: è un if-else il cui ramo else è un altro if-else, scritto senza rientrare ogni volta. Le condizioni si controllano dall’alto, e si esegue il ramo della prima vera; le altre non vengono neanche valutate. Se nessuna è vera si esegue l’ultimo else (se c’è).

Esempio 1, il segno di un numero (tre casi che si escludono):

#include <stdio.h>

int main(void)
{
    int x = -4;

    if (x > 0)
        printf("positivo\n");
    else if (x == 0)
        printf("zero\n");
    else
        printf("negativo\n");
    return 0;
}

Con x = -4: x > 0 falso, x == 0 falso, si arriva all’ultimo else. Output: negativo (verificato).

Esempio 2, catena contro if separati, con voto = 28:

#include <stdio.h>

int main(void)
{
    int voto = 28;

    if (voto >= 18) printf("sufficiente\n");
    if (voto >= 24) printf("buono\n");
    if (voto >= 28) printf("ottimo\n");
    printf("--\n");
    if (voto >= 28) printf("ottimo\n");
    else if (voto >= 24) printf("buono\n");
    else if (voto >= 18) printf("sufficiente\n");
    else printf("insufficiente\n");
    printf("--\n");
    if (voto >= 18) printf("sufficiente\n");
    else if (voto >= 24) printf("buono\n");
    else if (voto >= 28) printf("ottimo\n");
    else printf("insufficiente\n");
    return 0;
}

Output (verificato):

sufficiente
buono
ottimo
--
ottimo
--
sufficiente

2.2Precedenze nelle condizioni

(slide 28-34) Una condizione mescola tre tipi di operatori: logici (A && B), aritmetici (a * 2), relazionali (a <= b). Le regole (slide 29):

La tabella della slide 30, dall’alto (precedenza più alta) al basso:

gruppooperatoriassociatività
notazione infissa( ) [ ] . ->da sinistra a destra
unari! ++ -- * & sizeof - (type)da destra a sinistra
moltiplicativi* / %da sinistra a destra
additivi+ -da sinistra a destra
shifting>> <<da sinistra a destra
relazionali< <= > >=da sinistra a destra
uguaglianza!= e a == bda sinistra a destra
AND logico&&da sinistra a destra
OR logico||da sinistra a destra
condizionali?:da destra a sinistra
assegnazionex = y, +=, -=, …da destra a sinistra

La tabella completa, con i dettagli, è in Espressioni, operatori e costanti. Per le condizioni basta l’ordine a grandi blocchi:

unari  >  aritmetica  >  confronti  >  ==  !=  >  &&  >  ||  >  ?:  >  =

Quindi l’aritmetica si fa prima dei confronti, e i confronti prima di && e ||. Per questo x > 0 && x < 10 funziona senza parentesi.

Esempio della slide 34: a + b - 4 <= 9 && x < tot - 1. Si mettono le parentesi un gruppo alla volta, partendo dal più forte:

a + b - 4 <= 9 && x < tot - 1
((a + b) - 4) <= 9 && x < (tot - 1)          additivi, associativi da sinistra
(((a + b) - 4) <= 9) && (x < (tot - 1))      relazionali
((((a + b) - 4) <= 9) && (x < (tot - 1)))    AND logico, per ultimo

Con a=5a = 5, b=6b = 6, x=3x = 3, tot=10tot = 10, dal basso dell’albero verso l’alto:

a + b            5 + 6 = 11
11 - 4           7
7 <= 9           1  (vero)
tot - 1          10 - 1 = 9
3 < 9            1  (vero)
1 && 1           1

Verificato con printf: la condizione con e senza parentesi vale 1.

Altri tre esempi, dal più facile al più insidioso. I valori sono verificati con gcc, che su tutte e tre le righe dà un warning: è proprio il segnale che la scrittura inganna.

espressionevalorisi leggerisultato
!x > 2x=1x = 1(!x) > 2, cioè 0 > 20
!(x > 2)x=1x = 1!(1 > 2), cioè !01
a < b < ca=5a = 5, b=3b = 3, c=2c = 2(a < b) < c, cioè 0 < 21
a < b && b < cstessi0 && ...0
x % 2 == 0 || x > 10 && x < 20x=4x = 41 || ...1
stessax=15x = 150 || (1 && 1)1
stessax=25x = 250 || (1 && 0)0

2.3?: dentro le espressioni

?: sta quasi in fondo alla tabella: sotto ||, sopra solo l’assegnazione. Due conseguenze.

Lega meno dell’aritmetica. In r = 10 + a > b ? a : b; la condizione è tutto 10 + a > b:

#include <stdio.h>

int main(void)
{
    int a = 3;
    int b = 5;
    int r;

    r = 10 + a > b ? a : b;
    printf("r=%d\n", r);
    r = 10 + (a > b ? a : b);
    printf("r=%d\n", r);
    return 0;
}
istruzionesi leggecalcolor
r = 10 + a > b ? a : b;r = ((10 + a) > b) ? a : b;13 > 5 vero, vale a3
r = 10 + (a > b ? a : b);3 > 5 falso, vale b; 10 + 515

Output: r=3, poi r=15 (verificato, e gcc non avvisa). Quando ?: sta dentro un calcolo, va fra parentesi.

Associa da destra. a ? b : c ? d : e si raggruppa come a ? b : (c ? d : e): è la catena else if scritta come espressione. Esempio, il segno e il plurale:

#include <stdio.h>

int main(void)
{
    int x = -7;
    int n = 1;
    int s = x > 0 ? 1 : x < 0 ? -1 : 0;

    printf("segno di %d: %d\n", x, s);
    x = 0;
    printf("segno di %d: %d\n", x, x > 0 ? 1 : x < 0 ? -1 : 0);
    printf("%d %s\n", n, n == 1 ? "esame" : "esami");
    n = 3;
    printf("%d %s\n", n, n == 1 ? "esame" : "esami");
    return 0;
}

Con x=−7x = -7: x > 0 falso, si passa a x < 0 ? -1 : 0, vero, vale -1. Con x=0x = 0: falso, poi 0 < 0 falso, vale 0. Output (verificato):

segno di -7: -1
segno di 0: 0
1 esame
3 esami

2.4Graffe e indentazione

L’indentazione serve a chi legge (slide 16), il compilatore la ignora. Quello che conta sono le graffe. Tre versioni del massimo di due numeri (slide 35-37):

Il compilatore legge la slide 37 così:

if (a > b) {
    max = a;
    printf("massimo: %d", a);
} else {
    max = b;
}
printf("massimo: %d", b);

Regola che evita tutti e tre i problemi: graffe sempre, anche per una sola istruzione.

3Metodo

Tracciare un if.

  1. Scrivi i valori correnti delle variabili in una tabella, una colonna per variabile.
  2. Metti le parentesi implicite nella condizione, poi calcolala. Con && e || fermati appena il risultato è deciso (cortocircuito, Espressioni, operatori e costanti): i ++ e -- nella parte saltata non avvengono.
  3. Individua il ramo dalle graffe, non dall’indentazione. Senza graffe il ramo è una sola istruzione, fino al primo ;.
  4. Ogni else va all’if più vicino che non ha ancora un else. Se serve, riscrivi il frammento con le graffe esplicite prima di tracciarlo.
  5. In una catena else if ti fermi alla prima condizione vera.
  6. Aggiorna la tabella solo per le istruzioni del ramo eseguito, una riga per istruzione.

Scrivere una condizione. Traduci la frase in italiano pezzo per pezzo con && (e), || (o), ! (non). “x fra 1 e 10” è x >= 1 && x <= 10, mai 1 <= x <= 10. Se mescoli && e || metti le parentesi anche dove non servono.

Scegliere fra if e ?:. Se devi fare qualcosa di diverso nei due casi (stampare, assegnare variabili diverse, più istruzioni), if. Se devi solo scegliere un valore da assegnare o stampare, ?: va bene. Con più di due casi la catena else if si legge meglio di tanti ?: annidati.

4Esempi svolti a lezione

Esempi di sintassi (slide 14-15).

if (x == 0) z = 5; else y = z + w*y;
if (x == 0) {z = 5;} else {y = z + w*y;}
if ((x+y)*(z-2) > (23+v)) {z = x + 1; y = 13 + x;}
if ((x == y && z > 3) || w != y)
    z = 5;
else {
    y = z + w*y;
    x = z;
}

La prima e la seconda sono identiche: le graffe attorno a una sola istruzione non cambiano niente. Nella terza il blocco contiene due assegnazioni, eseguite entrambe o nessuna. Nella quarta la condizione è un’espressione logica: && per AND e || per OR, come in Algebra di Boole. Le parentesi attorno a x == y && z > 3 non sono obbligatorie (&& lega più di ||), ma il prof le mette per chiarezza.

Per esempio, con x=2x = 2, y=2y = 2, z=1z = 1, w=2w = 2 nella quarta: x == y vero, z > 3 falso, quindi && falso; w != y falso; 0 || 0 falso. Si esegue il ramo else: y = 1 + 2*2 = 5, poi x = 1.

La slide 16 scrive if (x>0) printf(x); else printf(-x); per stampare il valore assoluto, poi la stessa riga indentata su quattro righe per leggibilità. È lo pseudo-C del corso: in C vero il primo argomento di printf è la stringa di formato, e si scrive printf("%d", x).

Istruzioni scorrette e non canoniche (slide 17).

1)  if (x == 0)  else y = 34;
2)  if (x == 0)  a; else b + c;
  1. Scorretta: manca l’istruzione del ramo vero. gcc: expected expression before 'else' (verificato). Se nel caso vero non c’è niente da fare si nega la condizione: if (x != 0) y = 34;.
  2. Non canonica: compila, ma a; e b + c; calcolano un valore e lo buttano via. Non succede niente in nessuno dei due rami. gcc con -Wall avvisa due volte: statement with no effect (verificato).

Massimo di due numeri (slide 23). Il programma della slide, così com’è:

#include <stdio.h>

 /*Istruzione Condizionale
   Calcolo del massimo di due numeri*/

int main(int argc, char *argv[])
{
    int m,n,max;

    /*Legge il primo numero */
    scanf("%d",&m);
    printf("m=%d\n",m);

    /*Legge il secondo numero */
    scanf("%d", &n);
    printf("n=%d\n",n);

    if(m > n) max=m;  else max=n;

    printf("max=%d\n", max);
}

Compilato e provato: con input 7 3 stampa m=7, n=3, max=7; con 4 4 stampa max=4. Con i due numeri uguali m > n è falso e max prende n, che è lo stesso valore: il caso va bene senza trattarlo a parte. Con -Wextra gcc avvisa che argc e argv non sono usati (servono per gli argomenti da riga di comando); con int main(void) il warning sparisce. Manca return 0;, ma in main dal C99 è implicito.

La riga che conta è if(m > n) max=m; else max=n;, da tracciare così:

inputm > nramomax
7 37 > 3 veromax=m;7
3 73 > 7 falsomax=n;7
4 44 > 4 falsomax=n;4

Sfida: solo due variabili (slide 24). “È possibile usare solo due variabili, x e y?” Sì: se y è più grande la si copia in x, e alla fine x è il massimo. Si perde il valore iniziale di x, che non serve più.

#include <stdio.h>

int main(void)
{
    int x;
    int y;

    if (scanf("%d %d", &x, &y) != 2) {
        return 1;
    }
    if (y > x) {
        x = y;
    }
    printf("max=%d\n", x);
    return 0;
}
inputxyy > xx dopo
4 949vero9
9 494falso9

Stampa max=9 in tutti e due i casi (verificato). Un’altra strada è non salvare niente: printf("max=%d\n", x > y ? x : y);.

Dangling else (slide 20). Le due letture scritte con le graffe, con C1 falsa:

#include <stdio.h>

int main(void)
{
    int c1 = 0;
    int c2 = 1;

    if (c1) {
        if (c2) printf("S1\n");
        else printf("S2 (else del secondo if)\n");
    }

    if (c1) {
        if (c2) printf("S1\n");
    } else printf("S2 (else del primo if)\n");

    return 0;
}

Output: una sola riga, S2 (else del primo if) (verificato). Il primo if è la lettura b, quella che il C sceglie quando le graffe mancano: con C1 falsa non esegue niente. Il secondo è la lettura a.

Operatore ternario (slide 22). WEEKEND nella slide non è definito; qui è una costante con #define:

#include <stdio.h>

#define FERIALE 0
#define WEEKEND 1

int main(void)
{
    int day = WEEKEND;
    int opening_time = (day == WEEKEND) ? 12 : 9;

    printf("apre alle %d\n", opening_time);
    day = FERIALE;
    printf("apre alle %d\n", day == WEEKEND ? 12 : 9);
    return 0;
}

Output: apre alle 12, poi apre alle 9 (verificato). La versione con if ha bisogno di dichiarare prima la variabile e di due assegnazioni:

int opening_time;
if (day == WEEKEND) opening_time = 12; else opening_time = 9;

Esercizi 1a e 1b (slide 38-39). Quanto valgono x, y e z alla fine? Sulla slide, 1a:

main() {
  int x,y,z;
  y=1;
  z=0;
  x=1;
  if (x<=1)
  y=0;
  z=1;
  .......
}

Lo stesso, compilabile e con la stampa:

#include <stdio.h>

int main(void)
{
    int x;
    int y;
    int z;

    y = 1;
    z = 0;
    x = 1;
    if (x <= 1)
        y = 0;
    z = 1;
    printf("x=%d y=%d z=%d\n", x, y, z);
    return 0;
}
istruzionexyz
y = 1;?1?
z = 0;?10
x = 1;110
if (x <= 1): 1 <= 1 vero110
y = 0; (unica istruzione del ramo)100
z = 1; (fuori dall’if)101

Output: x=1 y=0 z=1 (verificato), come la soluzione della slide. L’1b mette y = 0; fra graffe:

#include <stdio.h>

int main(void)
{
    int x;
    int y;
    int z;

    y = 1;
    z = 0;
    x = 1;
    if (x <= 1) {
        y = 0;
    }
    z = 1;
    printf("x=%d y=%d z=%d\n", x, y, z);
    return 0;
}

Il risultato è identico, x=1 y=0 z=1 (verificato): con una sola istruzione nel ramo le graffe non cambiano niente. Il tranello è che sulla slide 1a l’indentazione non c’è, e viene da chiedersi se z=1; sia dentro l’if. Non lo è: z = 1; è eseguita comunque, anche se la condizione fosse falsa (lo mostra l’esercizio 1 qui sotto).

La slide scrive main() senza tipo. Era il C degli anni ‘80 (“int implicito”); dal C99 non è più valido, e gcc 14 e successivi lo rifiutano con error: return type defaults to 'int' (verificato con gcc 16). Si scrive int main(void).

5Esercizi tipo esame

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

6Errori tipici

7Domande