In questa lezione impareremo come far eseguire al calcolatore le stesse istruzioni un numero determinato di volte oppure fin quando non si verifica una certa condizione. In C/C++ i cicli sono divisi in due classi: cicli incondizionati o iterativi e cicli condizionati.

Il ciclo iterativo for
Numerose operazioni di elaborazione richiedono che determinate istruzioni vengano ripetute varie volte, un procedimento noto come iterazione. Il ciclo for segue un tracciato simile alla figura che segue:

Come vedremo tra breve, nella definizione del for viene specificato il numero di volte che il ciclo deve ripetersi tramite una variabile contatore. E' anche possibile creare cicli infiniti dai quali è possibile uscire utilizzando l'istruzione break vista nell'istruzione switch-case. La sintassi del ciclo for è la seguente:

for(valore iniziale; valore finale; incremento)
{
 //istruzioni
}

Esaminiamo una alla volta le 3 espressioni tra le parentesi tonde:

• Valore iniziale: in realtà è un assegnamento del tipo i=0; oppure i=-10; ma che comunque stabilisce il valore iniziale della variabile contatore.
• Valore finale: il valore finale che la variabile contatore assumerà viene specificato dalla valutazione di una espressione di controllo del tipo i<50; oppure i<100; ovvero la variabile contatore viene incrementata fino a che l'espressione precedente diventa falsa (i==50 o i==100).
• Incremento: è composto da una istruzione di assegnamento o incremento o ancora decremento del tipo i++; o i--; o infine i+=3; L'ultima istruzione fa procedere l'incremento a passi di 3. Per l'assegnamento di decremento fare attenzione a che il valore iniziale sia maggiore di quello finale altrimenti si cade in un ciclo infinito!!!

Vediamo qualche esempio:

#include <iostream.h>

int main()
{
    int x;
    
    for(x = 0; x < 10; x++)
    {
        cout << x  << endl;
    }
    return 0;
}

Questo esempio stampa a video uno sotto l'altro i numero da 0 a 9.
Come visto nella Lezione 5 per l'if-else ad una istruzione, anche per il for vale la regola che permette di eliminare le parentesi graffe solo se il corpo del ciclo è composto da una sola istruzione.

for(x = 0; x < 10; x++)
	cout << x  << endl;

Vediamo un altro esempio che esegue la somma di 5 numeri immessi dall'utente:

#include <iostream.h>
main()
{
    int loop;
    int total = 0;   // declare and initialize variables
    int number = 0;
    
    for(loop = 1; loop <= 5; loop++)
    {
        cout << "Enter a number : ";
        cin >> number;
        total += number; // keep running total
    }
    cout << endl << "The total is " << total;
    return 0;
}

L'esempio che segue scrive in lettere maiuscole il nome (o la stringa) inserita da tastiera:

#include <iostream.h>
#include <string.h>
#include <ctype.h>
#define MAX 20

int main()
{
    char name[MAX];
    int x;
    
    cout << "Enter a name : ";
    cin >> name;
    for (x = 0; x < strlen(name); x++)
    {
        name[x] = toupper(name[x]);
    }
    cout << endl << name << endl;
    return 0;
}

Concludiamo gli esempi con un ciclo infinito particolare:

...
for(;;) //Realizza il ciclo infinito
{
    //istruzioni
}
...

oppure

...
for(;;)
{
    if(condizione_uscita) break; //permette di uscire dal ciclo
    ...
}
...

NOTA: Anche se non è espressamente vietato dalla sintassi del linguaggio, si consiglia di evitare assolutamente di modificare la variabile contatore all'interno del ciclo perché si potrebbe incorrere in errori logici e cadere quindi in un ciclo infinito o eseguire il ciclo un numero inferiore rispetto a quando il calcolo ne richiede. Se si ha la necessità di modificare la variabile contatore, utilizzare uno dei cicli condizionati che seguono.

Ciclo condizionato while
L'istruzione di ciclo while è utilizzata per ripetere un gruppo di istruzioni fino a che rimane vera una espressione di controllo. Lo schema logico di questa istruzione è il seguente:

La sintassi di questa istruzione è la seguente:

while(condizione)
{
    //istruzioni che modificano le variabili della condizione
}

dove condizione è una qualunque espressione (complicata quanto basta) che ha come risultato true o false. Fino a che la condizione è vera le istruzioni tra le parentesi graffe vengono eseguite, in caso di falsità si esce fuori dal ciclo. Nella condizione è quindi possibile inserire una espressione contenente qualunque operatore di confronto (<, <=, >, >=, ==, !=) e/o logico (&&, ||, !).
Anche qui, come visto nella Lezione 5 per l'if-else ad una istruzione, vale la regola che permette di eliminare le parentesi graffe solo se il corpo del ciclo è composto da una sola istruzione.
Vediamo qualche esempio di utilizzo.

#include <iostream.h>

int main()
{
    int counter = 0; //set initial value
    
    while(counter < 10)
    {
        cout << counter << " "; //display
        counter++; //increment
    }
    return 0;
}

Il precedente listato di programma C++, stampa a video i numeri da 0 a 9.

#include <iostream.h>

int main()
{
    char lettera = 'b';
    while(lettera > 'a' && lettera < 'z')
    {
        cout << lettera << " ";
        lettera ++;
    }
    return 0;
}

Il precedente listato di programma C++, stampa a video le lettere minuscole dell'alfabeto dalla 'b' alla 'y'.
Anche con il ciclo while è possibile creare cicli infiniti. Un tipico esempio è il seguente:

...
while(true) //Realizza il ciclo infinito
{
    //istruzioni
}
...

Ciclo condizionato do-while
L'istruzione di ciclo do-while è utilizzata per ripetere un gruppo di istruzioni mentre rimane vera una condizione di controllo. Al contrario del while, le istruzioni sono eseguite almeno una volta. Lo schema logico è il seguente nel quale risulta evidente che se la condizione di controllo è vera si ripetono le istruzioni altrimenti si esce dal ciclo:

La sintassi è simile al while:

do{
	//istruzioni che modificano le variabili della condizione
}while(condizione);

Nella condizione è quindi possibile inserire una espressione contenente qualunque operatore di confronto (<, <=, >, >=, ==, !=) e/o logico (&&, ||, !).
Anche qui, come visto nella Lezione 5 per l'if-else ad una istruzione, vale la regola che permette di eliminare le parentesi graffe solo se il corpo del ciclo è composto da una sola istruzione.
Vediamo un esempio di utilizzo:

#include <iostream.h>
int main()
{
    int counter = 0; //set initial value
    do{
        cout << counter << " "; //display
        counter++; //increment
    }while(counter < 10); //test condition
    return 0;
}