Note Ingegneria Informatica · UniTN
Programmazione 1
Esercizi
in corso

Cicli for e do-while

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 ;:

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:

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:

Con i <= b i giri diventano b−a+1b - a + 1 e si esce con b+1b + 1. 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 −2-2.

Esempi, tutti verificati stampando il numero di giri e la i finale:

intestazionevalori di i nel corpogirii all’uscita
for (i = 0; i <= 10; i++)0, 1, …, 101111
for (i = 3; i < 3; i++)nessuno03
for (i = 1; i < 20; i *= 2)1, 2, 4, 8, 16532
for (i = 20; i >= 0; i -= 5)20, 15, 10, 5, 05-5
for (i = 0; i < 10; i += 4)0, 4, 8312
for (i = 100; i > 1; i /= 3)100, 33, 11, 341

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:

giroi a inizio corpoprintf("%d_", i++) stampai dopo il corpoi dopo espr3
100_ (vecchio valore)12
222_34
344_56
6 < 6 falso, esce

Il terzo:

giroi a inizio corpoprintf("%d_", ++i) stampai dopo il corpoi dopo espr3
101_ (prima aumenta, poi usa)12
223_34
345_56

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:

giron priman = n / 10cifren != 0
140714071vero
2407402vero
34043vero
4404falso, 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 n−1n - 1: 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:

ixx <= 0sommacontati
03falso31
1-1vero, continue31
20vero, continue31
37falso102
4-5vero, continue102
52falso123

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 (r,c)(r, c) va r⋅cr \cdot c.

#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 3⋅4=123 \cdot 4 = 12 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 N=4N = 4 ha 1, 2, 3, 4 asterischi: nella riga rr (da 1) ne stampo rr.

Modo 2, condizione sulla cella. Si disegna la griglia N×NN \times N con gli indici, e si trova la condizione su rr e cc che dice quando una cella è piena. Il triangolo è “colonna non oltre la riga”, cioè c≤rc \leq r.

#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 N−1N - 1:

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 rr cresce di 1 e cc cala di 1, e la somma r+cr + c resta fissa. Nella prima riga vale 0+(N−1)0 + (N - 1).

Quante volte gira il corpo interno. Con estremi fissi è il prodotto (R⋅CR \cdot C). Se l’interno dipende dall’esterno si sommano i giri riga per riga: con for (c = 1; c <= r; c++) e rr da 1 a NN sono 1+2+…+N=N(N+1)/21 + 2 + \ldots + N = N(N + 1)/2, per N=4N = 4 fanno 10, gli asterischi del triangolo.

3Metodo

Tracciare un for.

  1. Esegui espr1 una volta e scrivi la riga iniziale della tabella.
  2. Valuta espr2. Se è falsa ti fermi: quella riga dà i valori di uscita.
  3. Esegui il corpo, poi espr3, e scrivi una riga con i valori dopo l’aggiornamento.
  4. 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 (N⋅MN \cdot M), con j che parte da i è N+(N−1)+…+1=N(N+1)/2N + (N - 1) + \ldots + 1 = N (N + 1) / 2.

Stampare una figura con i cicli.

  1. Disegna la figura su una griglia e numera righe e colonne (da 0 o da 1, decidi subito e non cambiare).
  2. Scegli il modo: se ogni riga è fatta di pezzi contigui (spazi, poi asterischi) conta quanti caratteri di ogni tipo in funzione di rr; se i pezzi pieni sono sparsi scrivi la condizione su (r,c)(r, c).
  3. Verifica la formula su due righe, la prima e l’ultima: per la piramide con N=4N = 4 la riga 1 ha N−1=3N - 1 = 3 spazi e 2⋅1−1=12 \cdot 1 - 1 = 1 asterisco, la riga 4 ne ha 0 e 7.
  4. 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), e printf("\n") dopo.
  5. Il lato va in una #define o in una variabile, mai i numeri del disegno dentro i cicli: il testo d’esame chiede di solito che funzioni per ogni NN.
  6. Rileggi una riga a mano e confrontala col disegno.

Tradurre for in while.

  1. espr1 diventa un’istruzione prima del while.
  2. espr2 diventa la condizione del while.
  3. espr3 diventa l’ultima istruzione del corpo.
  4. Se nel corpo c’è un continue, prima di ogni continue va ripetuta espr3, altrimenti il while non 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:

contatorecontatore <= 5x lettosomma
1vero44
2vero711
3vero-29
4vero1019
5vero120
6falso, esce20

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;
}
ii <= 5Somma
1vero1
2vero3
3vero6
4vero10
5vero15
6falso, esce15

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: 1+2+3+4+5=5⋅6/2=151 + 2 + 3 + 4 + 5 = 5 \cdot 6 / 2 = 15.

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;
}
giroi nel printfi dopo i++; del corpoi dopo espr3
1012
2234
3456
4678
58910
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;
}
girolettoSommaletti == 1 && dato != 0
144vero
2711vero
3-29vero
41019vero
5019falso

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 −1-1, 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:

girocc != EOFnc
1'c'vero1
2'i'vero2
3'a'vero3
4'o'vero4
5'\n'vero5
6EOFfalso: niente ++nc, esce5

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;
}
ii <= 10i == 3cosa succede
1verofalsostampa i=1, espr3: i = 2
2verofalsostampa i=2, espr3: i = 3
3veroverobreak: 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;
}
ii == 3cosa succede
1, 2falsostampa
3verocontinue: salta il printf, va a espr3, i = 4
4, …, 10falsostampa
1111 <= 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

7Domande