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:
- assegnazione:
x = 23;,w = 'a';,y = z;,r3 = (alfa*43 - x)*(delta - 32*i);,x = x+1;; - condizionale: scegliere cosa eseguire (
if); - iterativa, o ciclo (loop): ripetere (
while, in Ciclo while ed esempi).
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
if | if-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).
- Si valuta la condizione.
- Se è VERA si esegue solamente la prima istruzione (o sequenza).
- Se è FALSA si esegue la seconda, quella dopo
else. - Se manca l’
elsee 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
- I tre
ifseparati sono indipendenti: ognuno si valuta, e 28 li soddisfa tutti, quindi tre stampe. - La catena si ferma alla prima condizione vera: una sola stampa,
ottimo. - La terza versione è il controesempio: stesse condizioni, ordine sbagliato.
voto >= 18è vera già al primo controllo, e i casibuonoeottimonon vengono mai raggiunti per nessun voto. In una catena di soglie si parte dalla condizione più stretta.
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):
- gli operatori sono divisi in gruppi con precedenze diverse, e quelli con precedenza superiore si valutano prima;
- fra operatori dello stesso gruppo decide l’associatività (da sinistra o da destra);
- le parentesi
()cambiano l’ordine, e si possono mettere anche solo per leggibilità.
La tabella della slide 30, dall’alto (precedenza più alta) al basso:
| gruppo | operatori | associatività |
|---|---|---|
| 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 == b | da sinistra a destra |
| AND logico | && | da sinistra a destra |
| OR logico | || | da sinistra a destra |
| condizionali | ?: | da destra a sinistra |
| assegnazione | x = 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 , , , , 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.
| espressione | valori | si legge | risultato |
|---|---|---|---|
!x > 2 | (!x) > 2, cioè 0 > 2 | 0 | |
!(x > 2) | !(1 > 2), cioè !0 | 1 | |
a < b < c | , , | (a < b) < c, cioè 0 < 2 | 1 |
a < b && b < c | stessi | 0 && ... | 0 |
x % 2 == 0 || x > 10 && x < 20 | 1 || ... | 1 | |
| stessa | 0 || (1 && 1) | 1 | |
| stessa | 0 || (1 && 0) | 0 |
!è unario e lega più di tutto:!x > 2negax, non il confronto. gcc:logical not is only applied to the left hand side of comparison.a < b < cnon vuol dire “b compreso fra a e c”: confronta il risultato (0 o 1) dia < bconc. Con 5, 3, 2 i numeri non sono in ordine e l’espressione vale lo stesso 1. gcc:comparisons like 'X<=Y<=Z' do not have their mathematical meaning.&&lega più di||, quindi l’ultima èx % 2 == 0 || (x > 10 && x < 20): “pari, oppure fra 11 e 19”. gcc suggerisce le parentesi attorno al&&(suggest parentheses around '&&' within '||'), anche se il risultato è giusto: mettile.
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;
}
| istruzione | si legge | calcolo | r |
|---|---|---|---|
r = 10 + a > b ? a : b; | r = ((10 + a) > b) ? a : b; | 13 > 5 vero, vale a | 3 |
r = 10 + (a > b ? a : b); | 3 > 5 falso, vale b; 10 + 5 | 15 |
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 > 0 falso, si passa a x < 0 ? -1 : 0, vero, vale -1. Con : 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):
- Slide 35, corretta: entrambi i rami fra graffe, ognuno assegna
maxe stampa.if(a > b) { max = a; printf ("massimo: %d", a); } else { max = b; printf ("massimo: %d", b); } - Slide 36: il ramo
ifsenza graffe e con due istruzioni.
L’if(a > b) max = a; printf ("massimo: %d", a); else { max = b; printf ("massimo: %d", b); }ifcontrolla solomax = a;. Ilprintfè un’istruzione normale, e dopo di lui l’elsenon ha nessunifa cui attaccarsi. Non compila: gcc dàerror: 'else' without a previous 'if'(verificato), e prima ancora il warningthis 'if' clause does not guard.... - Slide 37: il ramo
elsesenza graffe.
Compila, ma l’if(a > b) { max = a; printf ("massimo: %d", a); } else max = b; printf ("massimo: %d", b);elsecontrolla solomax = b;. Il secondoprintfè fuori dall’if-elsee viene eseguito sempre. Con e il programma stampamassimo: 5e poimassimo: 3, emaxvale 5 (verificato). gcc con-Wallavvisa (this 'else' clause does not guard...,-Wmisleading-indentation), perché l’indentazione fa credere il contrario.
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.
- Scrivi i valori correnti delle variabili in una tabella, una colonna per variabile.
- 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. - Individua il ramo dalle graffe, non dall’indentazione. Senza graffe il ramo è una sola istruzione, fino al primo
;. - Ogni
elseva all’ifpiù vicino che non ha ancora unelse. Se serve, riscrivi il frammento con le graffe esplicite prima di tracciarlo. - In una catena
else ifti fermi alla prima condizione vera. - 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 , , , 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;
- 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;. - Non canonica: compila, ma
a;eb + c;calcolano un valore e lo buttano via. Non succede niente in nessuno dei due rami. gcc con-Wallavvisa 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ì:
| input | m > n | ramo | max |
|---|---|---|---|
7 3 | 7 > 3 vero | max=m; | 7 |
3 7 | 3 > 7 falso | max=n; | 7 |
4 4 | 4 > 4 falso | max=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;
}
| input | x | y | y > x | x dopo |
|---|---|---|---|---|
4 9 | 4 | 9 | vero | 9 |
9 4 | 9 | 4 | falso | 9 |
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;
}
| istruzione | x | y | z |
|---|---|---|---|
y = 1; | ? | 1 | ? |
z = 0; | ? | 1 | 0 |
x = 1; | 1 | 1 | 0 |
if (x <= 1): 1 <= 1 vero | 1 | 1 | 0 |
y = 0; (unica istruzione del ramo) | 1 | 0 | 0 |
z = 1; (fuori dall’if) | 1 | 0 | 1 |
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
if (x = 0)invece diif (x == 0): assegna 0 axe la condizione vale sempre falso. gcc-Wallavvisa (suggest parentheses around assignment used as truth value).- Punto e virgola dopo la condizione:
if (x > 0);è unifcon istruzione vuota, e quello che segue viene eseguito sempre. gcc-Wextraavvisa (suggest braces around empty body in an 'if' statement). ;fra}edelse:if (c) { ... }; else { ... }non compila ('else' without a previous 'if'), perché il;è un’istruzione vuota che chiude l’ife l’elseresta orfano.- Due istruzioni in un ramo senza graffe (slide 36 e 37).
- Credere all’indentazione per l’
else: va all’ifpiù vicino. 1 <= x <= 10al posto di1 <= x && x <= 10.!x > 2per dire “non maggiore di 2”:!si applica solo ax. Serve!(x > 2), o megliox <= 2.- Catena
else ifcon le soglie in ordine sbagliato: la condizione più larga per prima nasconde le altre. ?:dentro un calcolo senza parentesi:10 + a > b ? a : busa10 + a > bcome condizione.- Usare
?:come istruzione con effetti (a > b ? x = 1 : y = 2;): non compila (lvalue required as left operand of assignment), perché?:lega più di = e il compilatore legge(a > b ? x = 1 : y) = 2.?:serve per scegliere un valore; per scegliere cosa fare c’è l’if. - Scrivere
main()senzaint.
7Domande
-
Qual è la sintassi di
ife diif-else? -
Descrivi la semantica di un
if-elsein quattro passi. -
Quando una condizione è considerata vera in C?
-
Cos’è un’istruzione composta e perché serve negli
if? -
A quale
ifsi attacca unelseinif (C1) if (C2) S1; else S2;? Come si ottiene l’altra lettura? -
Che differenza c’è fra l’operatore
?:e unif-else? -
Metti le parentesi implicite in
a + b - 4 <= 9 && x < tot - 1. -
Perché il programma della slide 36 non compila?
-
Cosa stampa il programma della slide 37 con
a = 5eb = 3, e perché? -
Come trovi il massimo di due numeri usando solo le due variabili
xey? -
Nell’esercizio 1a quanto valgono
x,y,zalla fine? Cambia qualcosa nell’1b? -
Con
a = 5eb = 0, quanto valebdopoif (a > 3 || b++ > 0) ...? -
Perché
if (x == 0) else y = 34;è scorretta e come la riscrivi? -
In una catena
if ... else if ... else, quanti rami vengono eseguiti al massimo? Perché l’ordine delle condizioni conta? -
Cosa succede con
if (x > 0);seguito da un’istruzione? -
Perché
1 <= x <= 10non controlla chexstia fra 1 e 10? Quanto vale conx = 50? -
Come si raggruppa
a ? b : c ? d : e, e quanto valerdopor = 10 + a > b ? a : b;cona = 3eb = 5?