FlooidArt Blog

Spesso, in molte applicazioni, è necessario ripetere blocchi di codice più volte. Tutti i linguaggi di programmazione mettono a disposizione per le iterazioni una serie di istruzioni ad hoc.
Il C#, che non è da meno, ne mette a disposizione quattro, che sono:

• while
• do
• for
• foreach

While:

Questa istruzione consente di ripetere un blocco di codice fintanto che una determinata condizione viene verificata (true). La sintassi è questa:

    while (condizione)
        {
              // istruzioni
        }

Praticamente l'istruzione verrà eseguita finchè la condizione non risulterà falsa, vediamo un esempio:

1 using System;
2 class Tabellina
3       {
4           public static void Main()
5                {
6                  // dichiaro la variabile i
7                  // che fa da contatore che parte da 1
8                  int i=1;
9
10                // variabile che contiene il numero digitato
11               int num=0;
12
13               // stampo il messaggio per l'utente
14               Console.Write("Inserisci il numero (max 10) = ");
15
16               // leggo il numero da tastiera ed eseguo la 
17               // conversione a numero intero
18               num=Convert.ToInt32(Console.ReadLine());
19
20               // eseguo il ciclo  while
21               while(i<=10)

22                {
23                   Console.WriteLine("\n {0} x {1}= {2}",i,num,num*i);
24                   // incremento il contatore
25                   ++i;
26                }
27
28                // attendo un carattere  qualsiasi
29                // digitato per chiudere il programma
30                Console.ReadLine();
31                }
32        }

L’istruzione while della riga 21, testa la condizione tra parentesi ed esegue il blocco di codice contenuto tra le parentesi graffe, fino a quando il contatore i diventa maggiore di 10. A questo punto la condizione diventa falsa (false) ed il ciclo termina passando il controllo all’istruzione della riga 30. Una breve considerazione merita l’istruzione della riga 23. I parametri {0}, {1} e {2} fanno riferimento, per la stampa, rispettivamente alle variabili i, num ed il calcolo diretto num*i. Per quest’ultimo, non ho utilizzato una variabile per memorizzare il risultato dell’operazione, ma l’ho passata direttamente affinchè venisse stampato il risultato. Questo solo a dimostrazione di come sia versatile il metodo WriteLine (in genere il metodo Write) della classe Console.

Infine, un costrutto while può essere interrotto in base ad una eventuale condizione interna al blocco di codice con l’istruzione break. Per esempio, avrei potuto (anche se non ha molto senso) interrompere il ciclo while del codice precedente non appena il il risultato dell’operazione num*i fosse diventato maggiore di 25, in questo modo:

// eseguo il ciclo while
      while(i<=10)
         {
           if ((num*i)>25) break;  // interrompo
           Console.WriteLine("\n {0} x {1}= {2}",i,num,num*i);
           // incremento il contatore
          ++i;
         }

L’istruzione break interrompe il ciclo e passa il controllo all’istruzione immediatamente successiva al ciclo stesso. Questa prassi potrebbe risultare più utile in quei casi in cui è ignoto il numero di iterazioni da effettuare. Potremmo utilizzare un costrutto simile al seguente:

// eseguo il ciclo while che è sempre verificato
      while(true)
         {
            if ( condizione) break; 
            // interrompo
            // codice
          }

il test del while è sempre vero (true) quindi il ciclo prosegue ad iterare fino a quando la condizione dell’istruzione ifrisulta verificata.

Do:

A volte è necessario fare eseguire il blocco di codice, all’interno di un ciclo, almeno una volta. Nel ciclo while, che abbiamo visto in precedenza, il blocco di codice al suo interno, potrebbe non essere mai eseguito. Ciò può verificarsi se il test risulta falso (false) proprio quando l’istruzione viene eseguita per la prima volta. Per avere la sicurezza che il blocco di codice venga eseguito almeno una volta, ci affidiamo al costrutto do, in questo modo:

 do
    {
       // istruzioni
    }while(condizione);

Il costrutto denota subito che le istruzioni vengono eseguite prima che venga testata la condizione che se risulta vera (true), ripeterà il blocco di codice. La situazione si ripete fino a quando il test risulterà falso (false).

Vediamo l’esempio precedente ma con il ciclo Do:

1 using System;
2 class Tabellina
3      {
4          public static void Main()
5            {
6               // dichiaro la variabile i
7               // che fa da contatore che parte da 0
8               int i=0;
9
10              // variabile che contiene il numero digitato
11              int num=0;
12
13              // stampo il messaggio  per l'utente
14             Console.Write("Inserisci il numero (max 10) = ");
15
16               // leggo il numero da tastiera ed eseguo la
17              // conversione a numero intero
18              num=Convert.ToInt32(Console.ReadLine());
19              // eseguo il ciclo do
20              do
21              {
22                    // incremento il contatore e poi stampo
23                    ++i;
24                    Console.WriteLine("\n {0} x {1}= {2}",i,num,num*i);
25
26               } while(i<10);
27              // attendo un carattere  qualsiasi
28              // digitato per chiudere il programma
29              Console.ReadLine();
30            }
31      }

Nell'esempio c’è poco da commentare tranne per il test while(i<10). Come notate, rispetto all'esempio precedente, nel test è sparito il simbolo "=" perché dal momento in cui il contatore "i", che ora parte da 0, assume come valore 10, vuol dire che è stato raggiunto l’ultimo valore e dopo aver effettuato la stampa delle variabili e del calcolo, il test risulterà falso (false), quindi il programma prosegue con la prima istruzione dopo il ciclo (riga 32). Inoltre il contatore "i" viene incrementato prima della stampa in modo tale da avere una numerazione esatta da 1 a 10 appunto.

For:


Nei cicli che abbiamo descritto in precedenza, abbiamo fatto uso di contatori che in qualche modo hanno influenzato l’andamento dei cicli stessi. Infatti abbiamo inizializzato una variabile contatore, ne abbiamo verificato il valore, ne abbiamo incrementato il valore, ecc. tutto con istruzioni separate.

Con il ciclo for facciamo praticamente le stesse cose ma con un unico costrutto:
    for(contatore; condizione; incremento)
      {
            //istruzioni
       }
per esempio:
   for(int i=1; i<=10; i++)
     {
          // istruzioni
      }

abbiamo dichiarato una variabile assegnandole il valore iniziale 1: int i=1;
abbiamo imposto il test: i<=10;
ne abbiamo incrementato il valore: i++ .