Uscita dai cicli in linguaggio C

Nelle precedenti lezioni abbiamo visto come scrivere cicli iterativi in linguaggio C usando le istruzioni for, while e do while. Per il caso di cicli for e while abbiamo visto che possiamo uscire dal ciclo prima del corpo del ciclo stesso se la condizione di controllo non è più vera. Nel caso dei cicli do while, invece, si può uscire immediatamente dopo il corpo del ciclo nel caso in cui la condizione di controllo risulti falsa.

Nella realizzazione di programmi, tuttavia, potrebbe sorgere la necessità di interrompere l'iterazione corrente di un ciclo, oppure di interrompere del tutto il ciclo, in un punto arbitrario.

Nel linguaggio di programmazione C, le istruzioni break e continue sono utilizzate a questo scopo all'interno di un ciclo per modificare il normale flusso di esecuzione del codice. L'istruzione break permette di uscire immediatamente dal ciclo o dalla struttura di controllo in cui è presente, mentre l'istruzione continue interrompe l'iterazione corrente e passa alla successiva.

In questo articolo, esamineremo in dettaglio l'utilizzo di queste istruzioni e forniremo esempi di come possono essere utilizzate nella pratica.

Istruzione break

Abbiamo già visto nella lezione sull'istruzione switch come adoperando l'istruzione break sia possibile trasferire il controllo di flusso al di fuori di un'istruzione switch.

Analogamente è possibile utilizzare l'istruzione break per uscire da un ciclo for, while o do.

Proviamo ad analizzare un esempio. Supponiamo di voler realizzare un programma che controlla se un numero n sia un numero primo o meno. Una possibile tecnica è quella di utilizzare un ciclo for che divida la variabile n per tutti i numeri compresi tra 2 ed . Quando, durante il ciclo for, troviamo un numero che divide n è inutile continuare ad iterare in quanto sappiamo già che n non è un numero primo. Per questo possiamo uscire prima dal ciclo for utilizzando l'istruzione break.

Successivamente, dopo che il ciclo è terminato, possiamo adoperare un'istruzione if per controllare se:

• la terminazione del ciclo è stata prematura, quindi n non è primo;
• la terminazione del ciclo è stata normale, quindi n è primo.

Possiamo realizzare il programma in questo modo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

/* Verifica se un numero intero sia primo o meno */
#include <stdio.h>

int main() {
    int n;
    int d; /* divisore */

    printf("Inserisci il numero da controllare: ");
    scanf("%d", &n);

    for (d = 2; d < n; ++d) {
        if (n % d == 0) {
            break;
        }
    }

    /* Controllo finale */
    if (d < n) {
        printf("%d non è primo ma divisibile per %d\n", n, d);
    }
    else {
        printf("%d è primo\n");
    }

    return 0;
}

Provando a compilare ed eseguire il programma di sopra, otteniamo i seguenti possibili output:

Inserisci il numero da controllare: 37
37 è primo

Inserisci il numero da controllare: 56
56 non è primo ma divisibile per 2

L'istruzione break risulta molto utile anche in casi in cui bisogna uscire da cicli in punti differenti dall'inizio o dalla fine. Un possibile esempio sono i cicli che leggono l'input da parte dell'utente e terminano quando un valore particolare è stato inserito.

Prendiamo un esempio. Supponiamo di voler implementare un programma che richiede all'utente una serie di numeri interi maggiori di zero di cui ne calcola successivamente la somma. Per far questo possiamo usare un ciclo for che continua a leggere i numeri da riga di comando fin quando non viene inserito zero:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

/* Somma numeri interi */
#include <stdio.h>

int main() {
    int s, x;
    s = 0;
    for (;;) {
        printf("Inserisci un numero (0 per uscire): ");
        scanf("%d", &x);
        if (x == 0)
            break;
        s += x;
    }

    printf("La somma dei numeri inseriti è: %d\n", s);

    return 0;
}

Compilando ed eseguendo il programma, un possibile output è il seguente:

Inserisci un numero (0 per uscire): 1
Inserisci un numero (0 per uscire): 2
Inserisci un numero (0 per uscire): 3
Inserisci un numero (0 per uscire): 4
Inserisci un numero (0 per uscire): 5
Inserisci un numero (0 per uscire): 6
Inserisci un numero (0 per uscire): 7
Inserisci un numero (0 per uscire): 8
Inserisci un numero (0 per uscire): 9
Inserisci un numero (0 per uscire): 0
La somma dei numeri inseriti è: 45

Come si può osservare, nel programma abbiamo usato un ciclo for infinito alla riga 7. Questo ciclo for richiede un numero in input all'utente e lo somma alla variabile s ad ogni iterazione. Il ciclo procede all'infinito finché non viene inserito il numero 0. Così facendo alla riga 11 viene eseguita l'istruzione break che esce dal ciclo.

Un'altra importante caratteristica dell'istruzione break da tenere presente è che questa istruzione esce dal ciclo più interno. Ad esempio, se si hanno cicli innestati in questo modo:

while ( ... ) {
    for ( ... ) {
        ...
        break;
        ...
    }
}

L'istruzione break in questo caso esce dal ciclo for e restituisce il controllo al ciclo while più esterno. In sostanza, l'istruzione break esce dal ciclo o dall'istruzione switch in cui si trova.

Istruzione continue

L'istruzione continue ha un comportamento simile all'istruzione break, nel senso che termina l'iterazione corrente del ciclo. La differenza è che l'istruzione break trasferisce il controllo al punto immediatamente successivo al termine del ciclo mentre l'istruzione continue trasferisce il controllo al punto immediatamente precedente il termine del ciclo.

In altre parole, con break si esce dal ciclo, con continue il controllo rimane all'interno del ciclo e passa all'iterazione successiva.

La seconda differenza è che break può essere usata all'interno di un'istruzione switch. L'istruzione continue non può essere utilizzata all'interno di uno switch e il suo utilizzo è limitato ai cicli.

Proviamo a studiare un esempio. Supponiamo di voler modificare il programma che somma i numeri interi positivi introdotti dall'utente in input. Piuttosto che sommare un numero arbitrario di numeri e terminare quando viene inserito lo zero, modifichiamo il programma in maniera tale che vengano sommati esattamente 10 numeri. In questo caso però evitiamo di sommare numeri negativi o pari a zero:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

/* Somma di 10 numeri interi */
#include <stdio.h>

int main() {
    int s, x, i;
    s = 0;
    while (i < 10) {
        printf("Inserisci l'addendo %d: ", i + 1);
        scanf("%d", &x);
        if (x <= 0)
            continue;
        s += x;
        ++i;
    }

    printf("La somma dei 10 numeri inseriti è: %d\n", s);

    return 0;
}

Compilando ed eseguendo il programma, un possibile output che possiamo ottenere è il seguente:

Inserisci l'addendo 1: 10
Inserisci l'addendo 2: 20
Inserisci l'addendo 3: 30
Inserisci l'addendo 4: 40
Inserisci l'addendo 5: 50
Inserisci l'addendo 6: 60
Inserisci l'addendo 7: 70
Inserisci l'addendo 8: 80
Inserisci l'addendo 9: 90
Inserisci l'addendo 10: 100
La somma dei 10 numeri inseriti è: 550

Se proviamo ad inserire numeri negativi questo è quello che accade:

Inserisci l'addendo 1: 0
Inserisci l'addendo 1: -1
Inserisci l'addendo 1: 0
Inserisci l'addendo 1: 0
Inserisci l'addendo 1: 1
Inserisci l'addendo 2: 2
Inserisci l'addendo 3: 3
...

Inserendo numeri negativi o pari a zero, quello che accade è che l'istruzione continue alla riga 11 termina l'iterazione corrente e passa alla successiva. Le righe 12 e 13 non vengono eseguite e quindi la variabile i non viene incrementata così come il valore di s non viene modificato.

In Sintesi

In questa lezione abbiamo studiato due importanti istruzioni del linguaggio C:

• break: che termina un qualunque ciclo e passa il controllo alla prima istruzione che segue il ciclo;
• continue: che termina l'iterazione corrente di un ciclo per passare il controllo all'iterazione successiva.

Con queste due istruzioni è possibile controllare il comportamento di qualunque ciclo in linguaggio C.