Argomento di Programmazione 1. Fatto a lezione fra settembre e ottobre, deck 3.3: slide 3-15 (for e do-while), slide 32-34 (break e continue), slide 35-37 (Böhm-Jacopini). Prima: Ciclo while ed esempi. In mezzo al deck, slide 16-31: Switch.
Il filo del deck:
while già visto: valuta, poi esegue
|
for stesso ciclo, inizializzazione + condizione + aggiornamento in una riga
| utile quando il numero di giri è noto (slide 3-12)
do-while esegue, poi valuta: almeno un giro (slide 13-15)
|
switch selezione multipla (nota a parte, slide 16-31)
|
break/continue uscire dal ciclo, saltare al giro dopo (slide 32-34)
|
Böhm-Jacopini sequenza, if-else e while bastano per ogni algoritmo (slide 35-37)
1Definizioni
Ciclo for (slide 3-5). Il prof lo presenta come la forma compatta dello schema tipico del while con contatore, utile quando il numero di iterazioni è noto a priori (evidenziato sulla slide 5):
contatore = valIniz; for (contatore = valIniz;
while (contatore <= valFin) { contatore <= valFin;
... istruzioni da ripetere ... contatore++) {
contatore++; ... istruzioni da ripetere ...
} }
L’idea: nel while con contatore le tre cose che governano il ciclo (da dove parto, quando smetto, come avanzo) stanno sparse su tre righe lontane. Il for le raccoglie nell’intestazione, così chi legge vede subito quante volte gira.
Le tre parti dell’intestazione, separate da ;:
- espr1, l’inizializzazione: eseguita una sola volta, prima di tutto;
- espr2, la condizione: valutata all’inizio e a ogni iterazione, prima del corpo;
- espr3, l’aggiornamento: eseguito a ogni iterazione, dopo il corpo.
Come nel while, se la condizione è falsa subito il corpo si esegue zero volte.
Esempio 1, il conto alla rovescia: for (i = 5; i >= 1; i--) printf("%d ", i); stampa 5 4 3 2 1 ed esce con i a 0.
Esempio 2, zero giri: for (i = 3; i < 3; i++) non entra mai, perché 3 < 3 è falso già alla prima valutazione; i resta 3.
Equivalenza for-while (slide 9). L’intestazione può contenere espressioni qualunque, e
for (espr1; espr2; espr3) { espr1;
istruzioni while (espr2) {
} istruzioni
espr3;
}
fanno la stessa cosa. Unica eccezione: un continue nel corpo (vedi sotto). Il consiglio della slide: nel for usare espr1 solo per inizializzare la variabile di ciclo, espr2 solo per la condizione di uscita, espr3 solo per incrementarla o decrementarla. Il C permette di più, ma poi il ciclo non si legge.
Si può anche lasciare vuota una parte: for (; i < n; ) è un while; for (;;) senza condizione è un ciclo infinito (la condizione mancante vale vero), da cui si esce solo con break o return.
Ciclo do-while (slide 13).
do {
blocco istruzioni
} while (espressione);
Prima si esegue il corpo, poi si valuta la condizione: se è vera si ripete, se è falsa si esce. Quindi il corpo si esegue almeno una volta, anche se la condizione è falsa dall’inizio. Il ; dopo la parentesi è obbligatorio, a differenza di while e for.
A parole: il while è “guarda prima di saltare”, il do-while è “salta, poi guarda se rifarlo”. Nel flowchart della slide 13 il rombo sta dopo il blocco.
break (slide 32). Dentro un while, for, do-while o switch provoca l’uscita immediata da quell’istruzione. L’esecuzione continua con l’istruzione che la segue. Con due cicli annidati, break esce solo da quello più interno che lo contiene.
continue (slide 33). Dentro un while, for o do-while salta le istruzioni rimanenti del corpo e passa all’iterazione successiva. Non si applica allo switch. Dove va il salto:
- nel
whilee neldo-while, alla valutazione della condizione; - nel
for, all’aggiornamento espr3, e poi alla condizione.
Il disegno da tenere a mente: break esce dalla porta (dopo il ciclo, espr3 saltata), continue va in fondo alla stanza (a espr3, poi alla condizione).
Teorema di Böhm-Jacopini (slide 35-37). Il prof parte da tre domande: esistono algoritmi che non si possono scrivere con sequenze, if-else e while? Esistono strutture capaci di codificare qualsiasi algoritmo? Ne esistono di più potenti? La risposta, in teoria: sequenza, selezione (if-else) e ciclo (while) sono complete, cioè bastano a codificare qualsiasi algoritmo espresso con un diagramma di flusso.
Con le parole della slide 37: le strutture if-else e while sono equivalenti a quelle del linguaggio assemblatore, che modifica direttamente o sotto condizione il registro contatore di programma (PC, i salti visti in Architettura hardware e software di un calcolatore). Quello che si scrive con una si scrive con l’altra. E sono equivalenti alle strutture di controllo di qualsiasi altro linguaggio.
Conseguenza pratica: for, do-while e switch non aggiungono potenza, solo comodità. Ognuno si riscrive con while e if-else: il for con la traduzione della slide 9, il do-while con il corpo ripetuto davanti a un while (sotto, Concetti), lo switch con una catena di if (in Switch).
2Concetti
2.1Quante volte gira un for
Per il caso tipico for (i = a; i < b; i++), con la variabile non toccata nel corpo:
- il corpo gira volte (zero se );
- si esce con
iuguale a , il primo valore che rende falsa la condizione.
Con i <= b i giri diventano e si esce con . Con passo diverso da 1, per esempio i += 3, conviene elencare i valori: for (i = 10; i > 0; i -= 3) vede 10, 7, 4, 1 ed esce con .
Esempi, tutti verificati stampando il numero di giri e la i finale:
| intestazione | valori di i nel corpo | giri | i all’uscita |
|---|---|---|---|
for (i = 0; i <= 10; i++) | 0, 1, …, 10 | 11 | 11 |
for (i = 3; i < 3; i++) | nessuno | 0 | 3 |
for (i = 1; i < 20; i *= 2) | 1, 2, 4, 8, 16 | 5 | 32 |
for (i = 20; i >= 0; i -= 5) | 20, 15, 10, 5, 0 | 5 | -5 |
for (i = 0; i < 10; i += 4) | 0, 4, 8 | 3 | 12 |
for (i = 100; i > 1; i /= 3) | 100, 33, 11, 3 | 4 | 1 |
Nell’ultima riga / è la divisione intera: 100 / 3 = 33, 33 / 3 = 11, 11 / 3 = 3, 3 / 3 = 1, e 1 > 1 è falso.
Attenzione (slide 11-12): se il corpo modifica la variabile di ciclo, l’intestazione da sola non dice più niente. La regola della slide è non farlo mai.
2.2i++ e ++i: nell’intestazione e nel corpo
In espr3 i++ e ++i sono la stessa cosa: espr3 si esegue per il suo effetto (aumentare i) e il suo valore viene buttato, quindi la differenza fra postfisso e prefisso (Espressioni, operatori e costanti) non si vede. for (i = 0; i < 5; i++) e for (i = 0; i < 5; ++i) stampano tutti e due 0 1 2 3 4 ed escono con i a 5 (verificato).
Dentro il corpo invece la differenza conta, perché il valore viene usato dal printf, e in più ogni ++ nel corpo è un secondo aumento oltre a quello di espr3. È il tranello della prima provetta del 2024.
#include <stdio.h>
int main(void)
{
int i;
for (i = 0; i < 6; i++) {
printf("%d_", i);
}
printf("\n");
for (i = 0; i < 6; i++) {
printf("%d_", i++);
}
printf("\n");
for (i = 0; i < 6; i++) {
printf("%d_", ++i);
}
printf("\n");
return 0;
}
Output (verificato):
0_1_2_3_4_5_
0_2_4_
1_3_5_
Il secondo ciclo, giro per giro:
| giro | i a inizio corpo | printf("%d_", i++) stampa | i dopo il corpo | i dopo espr3 |
|---|---|---|---|---|
| 1 | 0 | 0_ (vecchio valore) | 1 | 2 |
| 2 | 2 | 2_ | 3 | 4 |
| 3 | 4 | 4_ | 5 | 6 |
6 < 6 falso, esce |
Il terzo:
| giro | i a inizio corpo | printf("%d_", ++i) stampa | i dopo il corpo | i dopo espr3 |
|---|---|---|---|---|
| 1 | 0 | 1_ (prima aumenta, poi usa) | 1 | 2 |
| 2 | 2 | 3_ | 3 | 4 |
| 3 | 4 | 5_ | 5 | 6 |
In tutti e due i avanza di 2 per giro, quindi 3 giri; cambia solo se si stampa il valore prima o dopo l’aumento. Questo programma modifica la variabile di ciclo nel corpo, proprio quello che la slide 12 dice di non fare: all’esame lo trovi apposta.
2.3Quale ciclo scegliere
numero di giri noto prima di partire for (contare, scorrere 1..N)
si ripete finché vale una condizione, while (sentinella, lettura fino a EOF,
e può non servire nemmeno un giro Euclide)
il corpo va eseguito almeno una volta, do-while (chiedere un input finché
e la condizione dipende da quel giro non è valido, menu, cifre)
Sono tutti equivalenti, quindi la scelta è di leggibilità. Il do-while è giusto quando il dato da controllare nasce dentro il corpo: con un while si dovrebbe leggere una volta prima del ciclo e una volta dentro, o inventare un valore iniziale finto.
Esempio, contare le cifre di un numero. Si divide per 10 finché resta qualcosa. Il numero 0 ha una cifra, e il do-while lo sa da solo perché fa sempre il primo giro:
#include <stdio.h>
int main(void)
{
int n;
int cifre;
if (scanf("%d", &n) != 1) {
return 1;
}
cifre = 0;
do {
n = n / 10;
cifre++;
} while (n != 0);
printf("cifre=%d\n", cifre);
return 0;
}
Con input 4071:
| giro | n prima | n = n / 10 | cifre | n != 0 |
|---|---|---|---|---|
| 1 | 4071 | 407 | 1 | vero |
| 2 | 407 | 40 | 2 | vero |
| 3 | 40 | 4 | 3 | vero |
| 4 | 4 | 0 | 4 | falso, esce |
Stampa cifre=4. Con 7 stampa cifre=1, con 0 cifre=1, con -305 cifre=3 (la divisione intera tronca verso zero: -305, -30, -3, 0). Lo stesso programma con while (n != 0) { ... } al posto del do-while dà gli stessi risultati tranne per 0, dove stampa cifre=0: sbagliato (verificati tutti).
2.4do-while come while
do { corpo
corpo while (cond) {
} while (cond); corpo
}
Il corpo scritto una volta prima del while fa il “giro garantito”. Al contrario, un while si scrive come do-while solo con un if davanti che controlla la condizione, altrimenti il primo giro avviene anche quando non dovrebbe.
2.5break e continue: due esempi oltre la slide
break per fermare una ricerca. Cercare il più piccolo divisore di n fra 2 e : appena se ne trova uno non serve guardare gli altri.
#include <stdio.h>
int main(void)
{
int n = 91;
int d;
for (d = 2; d < n; d++) {
if (n % d == 0) {
break;
}
}
if (d < n) {
printf("%d = %d * %d\n", n, d, n / d);
} else {
printf("%d primo\n", n);
}
n = 13;
for (d = 2; d < n; d++) {
if (n % d == 0) {
break;
}
}
if (d < n) {
printf("%d = %d * %d\n", n, d, n / d);
} else {
printf("%d primo\n", n);
}
return 0;
}
Output (verificato): 91 = 7 * 13, poi 13 primo. Con 91 il ciclo prova 2, 3, 4, 5, 6 (resto diverso da 0) e al 7 fa break: d resta 7. Con 13 nessun d divide, il ciclo finisce da sé e d vale 13. Il trucco è il valore di uscita: dopo il ciclo si guarda d per sapere come si è usciti. d < n vuol dire “uscito con il break”.
continue per scartare un dato. Leggere 6 interi e sommare solo i positivi:
#include <stdio.h>
int main(void)
{
int i;
int x;
int somma = 0;
int contati = 0;
for (i = 0; i < 6; i++) {
if (scanf("%d", &x) != 1) {
return 1;
}
if (x <= 0) {
continue;
}
somma += x;
contati++;
}
printf("positivi=%d somma=%d\n", contati, somma);
return 0;
}
Con input 3 -1 0 7 -5 2:
i | x | x <= 0 | somma | contati |
|---|---|---|---|---|
| 0 | 3 | falso | 3 | 1 |
| 1 | -1 | vero, continue | 3 | 1 |
| 2 | 0 | vero, continue | 3 | 1 |
| 3 | 7 | falso | 10 | 2 |
| 4 | -5 | vero, continue | 10 | 2 |
| 5 | 2 | falso | 12 | 3 |
Stampa positivi=3 somma=12 (verificato). Il continue salta somma e conteggio ma non i++: i numeri letti restano 6.
break in due cicli annidati esce solo dal ciclo interno:
#include <stdio.h>
int main(void)
{
int i;
int j;
for (i = 1; i <= 3; i++) {
for (j = 1; j <= 3; j++) {
if (j == 2) {
break;
}
printf("(%d,%d) ", i, j);
}
printf("fine riga i=%d j=%d\n", i, j);
}
return 0;
}
Output (verificato):
(1,1) fine riga i=1 j=2
(2,1) fine riga i=2 j=2
(3,1) fine riga i=3 j=2
A ogni giro esterno il ciclo interno stampa (i,1), con j == 2 fa break e si torna al ciclo esterno, che stampa fine riga e va avanti. Il ciclo esterno non si accorge di niente.
2.6Cicli annidati e figure
Un ciclo dentro un altro: per ogni giro del ciclo esterno il ciclo interno riparte da capo e fa tutti i suoi giri. Il modello mentale è l’orologio: la lancetta dei minuti (interno) fa un giro completo per ogni scatto di quella delle ore (esterno).
Per stampare una figura il ciclo esterno conta le righe r, quello interno le colonne c, e dopo il ciclo interno si va a capo. La riga di stampa si scrive da sinistra a destra e non si torna indietro: per questo l’ordine è sempre righe fuori, colonne dentro.
for (r = 0; r < R; r++) { una volta per riga
for (c = 0; c < C; c++) { una volta per carattere della riga
stampa il carattere della cella (r, c)
}
printf("\n"); a capo DOPO il ciclo interno, fuori dalle sue graffe
}
Esempio 1, la tabellina 3 × 4: nella cella va .
#include <stdio.h>
int main(void)
{
int r;
int c;
for (r = 1; r <= 3; r++) {
for (c = 1; c <= 4; c++) {
printf("%3d", r * c);
}
printf("\n");
}
return 0;
}
Output (verificato):
1 2 3 4
2 4 6 8
3 6 9 12
%3d stampa ogni numero su 3 caratteri allineati a destra, così le colonne restano in fila anche con il 12. Il corpo interno gira volte, una per numero.
Ci sono due modi di pensare una figura, e conviene saperli entrambi.
Modo 1, quanti caratteri per riga. Si conta, per ogni riga, quanti caratteri di ogni tipo ci sono, e si scrive un ciclo interno per ogni tipo. Il triangolo con ha 1, 2, 3, 4 asterischi: nella riga (da 1) ne stampo .
Modo 2, condizione sulla cella. Si disegna la griglia con gli indici, e si trova la condizione su e che dice quando una cella è piena. Il triangolo è “colonna non oltre la riga”, cioè .
#include <stdio.h>
#define N 4
int main(void)
{
int r;
int c;
for (r = 1; r <= N; r++) {
for (c = 1; c <= r; c++) {
printf("*");
}
printf("\n");
}
printf("--\n");
for (r = 0; r < N; r++) {
for (c = 0; c < N; c++) {
if (c <= r) {
printf("*");
} else {
printf(".");
}
}
printf("\n");
}
return 0;
}
Output (verificato):
*
**
***
****
--
*...
**..
***.
****
Nella seconda versione ho stampato . al posto dello spazio per far vedere le celle vuote; con lo spazio la figura è la stessa ma ogni riga ha spazi in coda, invisibili. Il modo 1 è più corto per triangoli e piramidi, il modo 2 è più comodo per cornici, diagonali e scacchiere, dove i pezzi pieni non sono contigui.
Le condizioni da sapere a memoria, sulla griglia con indici da 0 a :
c <= r triangolo in basso a sinistra
c >= r triangolo in alto a destra
r == c diagonale principale
r + c == N - 1 diagonale secondaria
r == 0 || r == N - 1 || c == 0 || c == N - 1 bordo (cornice)
(r + c) % 2 == 0 scacchiera
Il perché della diagonale secondaria: scendendo di una riga si va di una colonna a sinistra, quindi cresce di 1 e cala di 1, e la somma resta fissa. Nella prima riga vale .
Quante volte gira il corpo interno. Con estremi fissi è il prodotto (). Se l’interno dipende dall’esterno si sommano i giri riga per riga: con for (c = 1; c <= r; c++) e da 1 a sono , per fanno 10, gli asterischi del triangolo.
3Metodo
Tracciare un for.
- Esegui espr1 una volta e scrivi la riga iniziale della tabella.
- Valuta espr2. Se è falsa ti fermi: quella riga dà i valori di uscita.
- Esegui il corpo, poi espr3, e scrivi una riga con i valori dopo l’aggiornamento.
- Torna al passo 2.
Con break ti fermi subito e non esegui espr3; con continue salti il resto del corpo ma espr3 sì. Se nel corpo c’è un i++ o un ++i, nella tabella metti due colonne: i dopo il corpo e i dopo espr3.
Due for annidati. Il ciclo interno riparte da capo a ogni giro di quello esterno. Il totale dei giri del corpo interno è la somma, su ogni giro esterno, dei giri interni: con estremi fissi è il prodotto (), con j che parte da i è .
Stampare una figura con i cicli.
- Disegna la figura su una griglia e numera righe e colonne (da 0 o da 1, decidi subito e non cambiare).
- Scegli il modo: se ogni riga è fatta di pezzi contigui (spazi, poi asterischi) conta quanti caratteri di ogni tipo in funzione di ; se i pezzi pieni sono sparsi scrivi la condizione su .
- Verifica la formula su due righe, la prima e l’ultima: per la piramide con la riga 1 ha spazi e asterisco, la riga 4 ne ha 0 e 7.
- Scrivi il ciclo esterno sulle righe, dentro un ciclo per tipo di carattere (modo 1) o un ciclo sulle colonne con l’
if(modo 2), eprintf("\n")dopo. - Il lato va in una
#defineo in una variabile, mai i numeri del disegno dentro i cicli: il testo d’esame chiede di solito che funzioni per ogni . - Rileggi una riga a mano e confrontala col disegno.
Tradurre for in while.
- espr1 diventa un’istruzione prima del
while. - espr2 diventa la condizione del
while. - espr3 diventa l’ultima istruzione del corpo.
- Se nel corpo c’è un
continue, prima di ognicontinueva ripetuta espr3, altrimenti ilwhilenon aggiorna più la variabile e può non finire.
Tradurre while in for. L’inizializzazione prima del ciclo va in espr1, l’aggiornamento in fondo al corpo va in espr3. Se non c’è un aggiornamento “pulito” in fondo (sentinella, lettura con getchar) il while è già la scelta giusta.
Input con controllo del range.
do {
stampa la richiesta
leggi n (e controlla che scanf abbia letto)
} while (n fuori dal range);
La condizione del do-while è quella di errore: si ripete finché il dato è sbagliato.
4Esempi svolti a lezione
4.1Somma di n numeri in input, da while a for
(slide 6 e slide 8) La slide trasforma il ciclo con contatore in un for, con la freccia che porta le tre righe del while nell’intestazione. Il while di partenza:
int x, n=5;
int somma=0;
int contatore = 1;
while (contatore <= n){
scanf(x);
somma = somma + x;
contatore=contatore+1;
}
Il codice della slide legge con scanf(x);, che è sbagliato: scanf vuole la stringa di formato e l’indirizzo della variabile, cioè scanf("%d", &x) (gcc rifiuta scanf(x): passa un int dove serve una stringa). Versione corretta con il controllo dell’input:
#include <stdio.h>
int main(void)
{
int x;
int n = 5;
int somma = 0;
int contatore;
for (contatore = 1; contatore <= n; contatore++) {
if (scanf("%d", &x) != 1) {
printf("input non valido\n");
return 1;
}
somma = somma + x;
}
printf("somma=%d\n", somma);
return 0;
}
Con input 4 7 -2 10 1:
contatore | contatore <= 5 | x letto | somma |
|---|---|---|---|
| 1 | vero | 4 | 4 |
| 2 | vero | 7 | 11 |
| 3 | vero | -2 | 9 |
| 4 | vero | 10 | 19 |
| 5 | vero | 1 | 20 |
| 6 | falso, esce | 20 |
Stampa somma=20 (verificato). Nel while della slide c’erano int contatore = 1; prima del ciclo e contatore=contatore+1; in fondo al corpo: nel for finiscono rispettivamente in espr1 ed espr3, e la dichiarazione resta senza valore iniziale.
4.2Somma dei primi 5 interi con il for
(slide 7) La slide riprende il programma while di Ciclo while ed esempi, con i commenti del prof “Inizializzazione necessaria?” accanto a int Somma=0; e int n=5,i; e “Manca Qualcosa?” prima del ciclo:
#include <stdio.h>
int main(void)
{
int Somma = 0;
int n = 5;
int i;
i = 1;
while (i <= n) {
Somma += i;
i++;
}
printf("Somma= %d\n", Somma);
return 0;
}
Le risposte alle domande della slide: Somma = 0 è necessaria, perché Somma += i legge il valore vecchio e una variabile locale non inizializzata contiene un valore qualsiasi; i invece viene assegnata con i = 1 prima del ciclo, quindi la sua inizializzazione nella dichiarazione non serve. Riscritto con il for:
#include <stdio.h>
int main(void)
{
int Somma = 0;
int n = 5;
int i;
for (i = 1; i <= n; i++) {
Somma += i;
}
printf("Somma= %d\n", Somma);
return 0;
}
i | i <= 5 | Somma |
|---|---|---|
| 1 | vero | 1 |
| 2 | vero | 3 |
| 3 | vero | 6 |
| 4 | vero | 10 |
| 5 | vero | 15 |
| 6 | falso, esce | 15 |
Output Somma= 15 per entrambe le versioni (verificato). i=1; prima del while diventa espr1, i <= n resta la condizione, i++; in fondo al corpo diventa espr3. L’inizializzazione Somma=0 resta fuori: non è la variabile di ciclo. Controllo: .
4.3Quante volte gira
(slide 10-12) Tre domande in fila.
Slide 10. for (i=0; i<10; i++) printf("Hello World!\n"); stampa la riga 10 volte: i vale 0, 1, …, 9, ed esce con i a 10. La slide scrive le virgolette tipografiche (“Hello World!\n”): in C le stringhe vogliono le virgolette dritte ", con quelle curve il programma non compila.
#include <stdio.h>
int main(void)
{
int i;
for (i = 0; i < 10; i++) {
printf("Hello World!\n");
}
printf("i=%d\n", i);
return 0;
}
Stampa 10 volte Hello World! e poi i=10 (verificato).
Slide 11. Stesso ciclo, corpo qualunque: 10 volte, se il corpo non tocca i.
Slide 12. Con i++; anche dentro il corpo, ogni giro aumenta i di 2:
#include <stdio.h>
int main(void)
{
int i;
for (i = 0; i < 10; i++) {
printf("%d ", i);
i++;
}
printf("\nfine: i=%d\n", i);
return 0;
}
| giro | i nel printf | i dopo i++; del corpo | i dopo espr3 |
|---|---|---|---|
| 1 | 0 | 1 | 2 |
| 2 | 2 | 3 | 4 |
| 3 | 4 | 5 | 6 |
| 4 | 6 | 7 | 8 |
| 5 | 8 | 9 | 10 |
10 < 10 falso |
Output (verificato):
0 2 4 6 8
fine: i=10
Il corpo gira 5 volte, non 10. È il punto della slide: guardando solo l’intestazione non si può rispondere, quindi la variabile di ciclo non si modifica nel corpo.
4.4Somma con sentinella 0, con il do-while
(slide 14) La slide mostra il programma con il while (lo stesso di Ciclo while ed esempi): legge il primo dato prima del ciclo (“leggo dato prima ciclo (possibile sentinella)”) e lo rilegge in fondo al corpo.
int Somma,dato; //inizializzazione ?
/*Manca Qualcosa ? */
scanf("%d",&dato);
while(dato != 0){
Somma += dato;
scanf("%d",&dato);
}
printf("Somma= %d",Somma);
La slide chiede di riscriverlo con il do-while. Con il do-while la lettura sta una volta sola, dentro il corpo:
#include <stdio.h>
int main(void)
{
int Somma = 0;
int dato = 0;
int letti;
do {
letti = scanf("%d", &dato);
if (letti == 1) {
Somma += dato;
}
} while (letti == 1 && dato != 0);
printf("Somma= %d\n", Somma);
return 0;
}
| giro | letto | Somma | letti == 1 && dato != 0 |
|---|---|---|---|
| 1 | 4 | 4 | vero |
| 2 | 7 | 11 | vero |
| 3 | -2 | 9 | vero |
| 4 | 10 | 19 | vero |
| 5 | 0 | 19 | falso |
Con input 4 7 -2 10 0 99 stampa Somma= 19; con input 0 stampa Somma= 0; con input vuoto anche Somma= 0 (verificati). La sentinella viene sommata, ma sommare 0 non cambia niente: per questo qui il do-while funziona senza un if in più. Con una sentinella diversa, per esempio , andrebbe esclusa con un if (dato != -1).
La slide 14 dichiara int Somma,dato; senza inizializzare Somma (il commento “inizializzazione?” e “Manca qualcosa?” puntano proprio lì) e non controlla scanf: a fine input senza lo 0 il ciclo non finirebbe più.
4.5Conteggio dei caratteri, con il do-while
(slide 15) Il programma della slide conta i caratteri in input con while ((c = getchar()) != EOF) ++nc;, come in Input e output di caratteri. I commenti del prof: c è un “intero ma ANCHE un carattere”, ed “EOF è un int dichiarato in stdio.h. Il valore non importa”. Riscritto con il do-while, il carattere si legge nel corpo e il controllo di EOF va fatto due volte:
#include <stdio.h>
int main(void)
{
int c;
int nc = 0;
do {
c = getchar();
if (c != EOF) {
++nc;
}
} while (c != EOF);
printf("\nNumero Caratteri=%d\n", nc);
return 0;
}
Con input ciao più invio:
| giro | c | c != EOF | nc |
|---|---|---|---|
| 1 | 'c' | vero | 1 |
| 2 | 'i' | vero | 2 |
| 3 | 'a' | vero | 3 |
| 4 | 'o' | vero | 4 |
| 5 | '\n' | vero | 5 |
| 6 | EOF | falso: niente ++nc, esce | 5 |
Stampa Numero Caratteri=5 (l’a capo è un carattere); con input vuoto Numero Caratteri=0. Senza l’if, cioè con ++nc; e basta, conterebbe anche l’EOF: 6 e 1 (verificati entrambi).
Il conteggio dei caratteri è l’esempio in cui il do-while non conviene: l’input può essere vuoto, quindi il giro garantito non serve, e la versione while è più corta e più chiara. È la risposta da dare se all’esame chiedono quale dei due è meglio.
4.6break e continue nel for
(slide 34) Il programma della slide ha if (i == 3) break; e, commentata, la variante con continue.
#include <stdio.h>
int main(void)
{
int i;
for (i = 1; i <= 10; i++) {
if (i == 3) break;
printf("i=%d\n", i);
}
printf("Fine: i=%d\n", i);
return 0;
}
i | i <= 10 | i == 3 | cosa succede |
|---|---|---|---|
| 1 | vero | falso | stampa i=1, espr3: i = 2 |
| 2 | vero | falso | stampa i=2, espr3: i = 3 |
| 3 | vero | vero | break: esce, niente espr3 |
Output con break (verificato):
i=1
i=2
Fine: i=3
Con i == 3 si esce subito dal for: niente printf, niente i++. Per questo i vale 3 e non 4.
Con continue al posto di break:
#include <stdio.h>
int main(void)
{
int i;
for (i = 1; i <= 10; i++) {
if (i == 3) continue;
printf("i=%d\n", i);
}
printf("Fine: i=%d\n", i);
return 0;
}
i | i == 3 | cosa succede |
|---|---|---|
| 1, 2 | falso | stampa |
| 3 | vero | continue: salta il printf, va a espr3, i = 4 |
| 4, …, 10 | falso | stampa |
| 11 | 11 <= 10 falso, esce |
Stampa i=1, i=2, poi salta il 3 e prosegue da i=4 fino a i=10, e alla fine Fine: i=11 (verificato). Il continue salta il printf ma non l’i++ di espr3, quindi il ciclo arriva in fondo normalmente. La slide stampa "Fine: i=%d" senza \n finale.
5Esercizi tipo esame
In una pagina a parte, dal più facile al livello del 30: Cicli for e do-while (esercizi).
6Errori tipici
- Modificare la variabile di ciclo dentro il corpo del
for: il numero di giri non si legge più dall’intestazione (slide 12). - Credere che
i++e++iin espr3 diano risultati diversi: lì sono identici. Contano solo dove il valore viene usato, per esempio dentro unprintf. for (i = 0; i < 10; i++);con il punto e virgola: il corpo è l’istruzione vuota, il blocco dopo si esegue una volta sola conia 10.- Separare le parti del
forcon la virgola invece del;. - Dimenticare il
;dopowhile (cond)neldo-while. - Usare il
do-whilequando il caso “zero giri” è possibile (input vuoto, ): il primo giro avviene comunque. - Tradurre un
forconcontinuein unwhilesenza ripetere l’aggiornamento: ciclo infinito. - Credere che
breakesca da tutti i cicli annidati: esce solo da quello che lo contiene direttamente. - Pensare che
continuefunzioni nelloswitch: vale solo per i cicli. Uncontinuedentro unoswitchdentro un ciclo agisce sul ciclo. - Sbagliare il valore di uscita: dopo
for (i = 0; i < n; i++)la variabile vale , non . Dopo unbreakvale quello che aveva quando è scattato. - Nelle figure: mettere
printf("\n")dentro il ciclo interno (un carattere per riga) o dimenticarlo (tutto su una riga). - Nelle figure: scrivere i numeri del disegno dentro i cicli (
c < 5) invece diN, o stampare la figura con unaprintfper riga: se il testo chiede i cicli vale zero. scanf(x)come sulla slide 6: servescanf("%d", &x).
7Domande
-
Quali sono le tre parti dell’intestazione di un
for, e quando viene eseguita ciascuna? -
Come si riscrive
for (espr1; espr2; espr3) corpocon unwhile? -
In quale caso la traduzione di un
forinwhilenon è equivalente? -
Quante volte viene eseguito, al minimo, il corpo di un
do-while? E quello di unwhileo di unfor? -
Quando conviene il
for, quando ilwhile, quando ildo-while? -
Perché non si dovrebbe modificare la variabile di ciclo dentro il corpo di un
for? -
Cosa fa
breakdentro un ciclo? E dentro due cicli annidati? -
Cosa fa
continuein unfor? Dove salta in unwhile? -
Con quale valore esce
idafor (i = 1; i <= 10; i++) if (i == 3) break;? E concontinueal posto dibreak? -
Cosa dice il teorema di Böhm-Jacopini?
-
Quante volte gira il corpo interno di
for (i = 0; i < N; i++) for (j = i; j < N; j++)? -
C’è differenza fra
for (i = 0; i < n; i++)efor (i = 0; i < n; ++i)? E fraprintf("%d", i++)eprintf("%d", ++i)nel corpo? -
Cosa stampa
for (i = 0; i < 6; i++) printf("%d_", i++);? -
Perché per contare le cifre di un numero il
do-whileè meglio delwhile? -
Come si struttura un programma che stampa una figura ? Dove va il
printf("\n")? -
Quale condizione su riga
re colonnac(da 0 a ) descrive la cornice? E la diagonale secondaria? -
Dopo un
forcon unbreakdentro, come fai a sapere se il ciclo è finito da solo o con ilbreak?