Strutture di controllo e cicli in C
Come scegliere un ramo e sapere quando un ciclo finisce
La programmazione strutturata organizza il flusso con sequenza, selezione e iterazione. In C bisogna anche seguire le regole precise della sintassi. Per esempio, in un for il passo di aggiornamento avviene anche dopo continue.
Selezione e operatore condizionale
In if (a) if (b) f(); else g();, l’else appartiene all’if (b), il più vicino senza un else. Usiamo le graffe per rendere visibile il raggruppamento. L’operatore condizionale test ? x : y è un’espressione. Valuta il test e poi soltanto uno dei due operandi. int max = a >= b ? a : b; assegna il maggiore, scegliendo a a parità.
Uno switch seleziona in base a un’espressione di tipo intero. Le etichette case usano espressioni costanti intere distinte dopo la conversione. default copre i valori senza caso corrispondente. Una volta entrati, il flusso prosegue in sequenza fino a un break, un’altra uscita o la fine del blocco. Due etichette consecutive possono condividere intenzionalmente lo stesso corpo.
Cicli e trasferimenti di controllo
| Costrutto | Prima valutazione della guardia | Destinazione di continue |
|---|---|---|
while (guardia) | Prima del corpo, anche zero iterazioni. | La guardia. |
do { ... } while (guardia); | Dopo il primo corpo. | La guardia in fondo. |
for (inizio; guardia; passo) | Dopo l’inizializzazione e prima del corpo. | Il passo, poi la guardia. |
break esce dal ciclo o dallo switch più interno che lo contiene. continue riguarda il ciclo più interno, anche quando è scritto dentro uno switch annidato. Se traduciamo un for in while mettendo il passo in fondo al corpo, dobbiamo farlo eseguire anche sui percorsi di continue.
Con for (i = 0, j = n; i < j; ++i, --j), l’operatore virgola valuta prima l’operando a sinistra e poi quello a destra. Il valore dell’intera espressione è quello dell’operando a destra. La virgola che separa gli argomenti in f(i, j) non impone invece un ordine di valutazione.
Invariante, uscita e terminazione
Correttezza di un ciclo
Un invariante è una proprietà vera ogni volta che si raggiunge il test del ciclo. Si prova all’inizio e dopo ogni iterazione. All’uscita, invariante e guardia falsa devono implicare il risultato richiesto. Per la terminazione serve anche un argomento separato, per esempio una quantità intera non negativa che decresce a ogni iterazione.
Esempi guidati
Esempio 1. Contare gli elementi positivi
Problema. Dato un array di n interi, contare quanti sono strettamente positivi.
Svolgimento. All’inizio di ogni test, positivi è il conteggio negli elementi da 0 a i-1. Con i = 0 il prefisso è vuoto. Esaminiamo v[i] quando i < n e aggiorniamo il conteggio, poi incrementiamo i. Alla fine i == n e il prefisso coincide con l’array. La quantità n - i diminuisce fino a zero.
Programma completo C11. Se n == 0, la funzione consente un puntatore nullo perché non accede all’array.
#include <stddef.h>
#include <stdio.h>
static size_t conta_positivi(const int v[], size_t n)
{
size_t positivi = 0;
for (size_t i = 0; i < n; ++i) {
if (v[i] > 0) {
++positivi;
}
}
return positivi;
}
int main(void)
{
const int v[] = {3, -1, 0, 8, -2};
printf("%zu\n", conta_positivi(v, sizeof v / sizeof v[0]));
printf("%zu\n", conta_positivi(NULL, 0));
return 0;
}Output atteso
2
0Esempio 2. Euclide iterativo
Problema. Calcolare il massimo comun divisore di due interi non negativi, con almeno uno diverso da zero.
Svolgimento. Finché b != 0, sostituiamo (a, b) con (b, a % b). L’invariante è che il MCD della coppia corrente coincide con quello della coppia iniziale. Un divisore comune di a e b divide anche il resto a % b. Vale anche il passaggio inverso, perché a si ricostruisce come multiplo di b più il resto. A ogni passo, il nuovo b è strettamente minore del precedente e resta non negativo. All’uscita b == 0 e il risultato è a.
| Passo | a | b | Resto per il passo successivo |
|---|---|---|---|
| Inizio | 48 | 18 | 12 |
| 1 | 18 | 12 | 6 |
| 2 | 12 | 6 | 0 |
| Uscita | 6 | 0 |
Programma completo C11
#include <stdio.h>
static unsigned mcd(unsigned a, unsigned b)
{
while (b != 0u) {
unsigned resto = a % b;
a = b;
b = resto;
}
return a;
}
int main(void)
{
printf("%u\n", mcd(48u, 18u));
printf("%u\n", mcd(48u, 0u));
return 0;
}Output atteso
6
48La versione ricorsiva di Euclide applica la stessa identità in una nuova chiamata.
Errori frequenti
Errori da evitare
Errore · Usare
i <= nper attraversare un array dinelementi.Correzione · Usare
i < n, perché l’ultimo indice valido èn-1quando l’array contiene elementi.Errore · Scrivere
if (x = 0)per confrontare.Correzione · Scrivere
if (x == 0). L’assegnamento a zero modificaxe produce una condizione falsa.Errore · Lasciare un punto e virgola subito dopo
while (condizione)prima del blocco.Correzione · Rimuoverlo. Altrimenti il corpo del
whileè l’istruzione vuota. Il punto e virgola finale appartiene invece alla sintassi dido ... while.
Esercizi di prova
Esercizio 1. Associazione di else (Base)
Con a = 0 e b = 1, quale funzione chiama if (a) if (b) f(); else g();?
Soluzione
Nessuna. Il test esterno è falso e l’
elseappartiene all’if (b).
Esercizio 2. Casi consecutivi (Base)
Per x == 1, quali lettere vengono stampate da switch (x) { case 1: puts("A"); case 2: puts("B"); break; default: puts("C"); }?
Soluzione
AeB, una per riga. L’esecuzione entra incase 1e prosegue fino albreak.
Esercizio 3. Guardia iniziale (Intermedio)
Se n = 0, confronta while (n > 0) { --n; } e do { --n; } while (n > 0); con n di tipo int.
Soluzione
Il primo non esegue il corpo e lascia
n = 0. Il secondo esegue una volta il corpo e termina conn = -1.
Esercizio 4. Continue nel for (Intermedio)
Con for (int i = 0; i < 5; ++i) { if (i % 2 == 0) continue; printf("%d ", i); }, quali valori vengono stampati?
Soluzione
1 3. Anche quando si eseguecontinue,++iviene valutato prima del test successivo.
Esercizio 5. Correttezza e variante (Avanzato)
In un ciclo che conta gli zeri in v[0..n), formula invariante, guardia di uscita e variante.
Soluzione
Al test
i < n, il contatore è il numero di zeri nelle primeicelle e vale0 <= i <= n. A uscita,i == ne il conteggio è quello richiesto. La varianten - idiminuisce di uno dopo ogni passo.
Esercizio 6. Invertire le cifre con un while (Intermedio)
Nel seguente programma, traccia n, cifra e ris dopo ogni iterazione. Che cosa si ottiene partendo da 120 oppure da 0?
#include <stdio.h>
int main(void)
{
int n = 1234;
int ris = 0;
while (n > 0) {
int cifra = n % 10;
ris = ris * 10 + cifra;
n /= 10;
}
printf("%d\n", ris);
return 0;
}Soluzione
Iterazione n dopo la divisione cifra ris 1 123 4 4 2 12 3 43 3 1 2 432 4 0 1 4321 Il programma stampa
4321. Con120otteniamo21, perché un valore intero non conserva lo zero iniziale. Con0il corpo non si esegue e si stampa0. Per generalizzare a qualunqueintnon negativo, occorre verificare che il prossimoris * 10 + cifrasia rappresentabile prima di calcolarlo.
Provenienza del materiale
- Marco Anisetti, Introduzione alla Programmazione in Linguaggio C,
Appunti_di_fine_Unità_2.pdf, cap. 2, pp. 41–55 del PDF. - WG14, bozza C11 N1570, §§ 6.5.15, 6.5.17 e 6.8.4–6.8.6.
- Dispensa del corso,
C1PROG1B1L3_Semantica_grammatica_algoritmo.pdf(Lessico, sintassi, semantica e introduzione agli algoritmi).