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

CostruttoPrima valutazione della guardiaDestinazione 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
0

Esempio 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.

PassoabResto per il passo successivo
Inizio481812
118126
21260
Uscita60

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
48

La versione ricorsiva di Euclide applica la stessa identità in una nuova chiamata.


Errori frequenti

Errori da evitare

Errore · Usare i <= n per attraversare un array di n elementi.

Correzione · Usare i < n, perché l’ultimo indice valido è n-1 quando l’array contiene elementi.

Errore · Scrivere if (x = 0) per confrontare.

Correzione · Scrivere if (x == 0). L’assegnamento a zero modifica x e 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 di do ... 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();?

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"); }?

Esercizio 3. Guardia iniziale (Intermedio)

Se n = 0, confronta while (n > 0) { --n; } e do { --n; } while (n > 0); con n di tipo int.

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?

Esercizio 5. Correttezza e variante (Avanzato)

In un ciclo che conta gli zeri in v[0..n), formula invariante, guardia di uscita e variante.

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

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).