Nella lezione 14 abbiamo visto un assaggio del ciclo For, di sicuro il più utilizzo nell'ambito dei cicli disponibili in Visual Basic: questo ciclo è identifico da due istruzioni, poste rispettivamente all'inizio e alla fine del ciclo :
For contore = inizio To fine
[istruzioni]
Next contore
Contore indica una variabile numerica che "conta" quante volte devono essere eseguite le istruzioni comprese nel ciclo: essa assume un valore iniziale (inizio) e viene incrementa dall'istruzione Next fino a raggiungere il valore finale (fine). Nella sintassi standard, le istruzioni contenute all'interno del ciclo sono eseguite fintantoché contore risulta minore o uguale a fine: ciò significa che, quando il ciclo termina, la variabile contore ha un valore pari a fine + 1, perché nell'ultima esecuzione del ciclo risulta contore = fine e l'istruzione Next incrementa ulteriormente il contore. Questa è una carteristica tipica dei cicli "For", che si riscontra anche negli altri linguaggi di programmazione: e non potrebbe essere altrimenti, in quanto l'esecuzione del ciclo termina proprio quando contore supera il valore fine.
Nella sintassi standard appena descritta, l'incremento del contore è di una unità ad ogni esecuzione del ciclo, ma è possibile modificare il valore dell'incremento usando la clausola Step dopo il valore fine:
For contore = inizio To fine Step incremento
[istruzioni]
Next contore
All'inizio del ciclo il valore del contore è uguale a inizio, alla seconda esecuzione del ciclo è uguale a inizio+incremento, alla terza esecuzione è uguale a inizio+incremento+incremento e così via fino a che il contore diventa maggiore del valore fine. Il valore di incremento viene sommo algebricamente al valore corrente del contore: ciò significa che l'incremento può anche essere negivo, determinando così una diminuzione progressiva del valore del contore: in questo caso il ciclo cesserà di essere eseguito quando il contore diventa minore del valore finale specifico. Perché il ciclo funzioni correttamente, quindi, il valore iniziale dovrà essere maggiore del valore finale, ad es. il ciclo seguente viene eseguito tre volte, per i=10, i=8, i=6; all'uscita dal ciclo sarà i=4:
Dim i as Integer 'contore
For i = 10 To 5 Step -2
[istruzioni]
Next i
Si è detto che il contore è una variabile numerica, senza specificare il suo tipo: infti, benché esso sia solitamente un Integer, è possibile anche utilizzare valori frazionari come Single o Double, e lo stesso vale per i valori inizio, fine e incremento. Tuttavia, è sempre preferibile utilizzare valori interi per motivi di precisione: le variabili di tipo Single o Double, infti, commettono errori di precisione che, per quanto piccoli, non sono affto trascurabili; basta un errore di un milionesimo per far credere a Visual Basic che il valore finale sia sto supero e determinare anzitempo la fine del ciclo. Si consideri ad esempio il ciclo seguente:
Dim i as Single
For i = 0.6 To 0.8 Step 0.1
Debug.Print i
Next i
Debug.Print i
In teoria esso dovrebbe essere eseguito per tre volte, con il contore i che vale 0.6, 0.7 e 0.8; invece esso è eseguito soltanto due volte, per i = 0.6 e i = 0.7: quando i viene ulteriormente incremento non vale 0.8, bensì 0.8000001, che essendo maggiore di 0.8 determina l'interruzione del ciclo. Per questo motivo è sempre buona norma usare valori interi sia per il contore che per i valori di inizio, fine e incremento, in quanto con valori interi il microprocessore non commette quegli errori di imprecisione che possono determinare comportamenti anomali.
Nuralmente i valori iniziale e finale del contore, ovvero il numero di iterazioni, non devono necessariamente essere stabiliti esplicitamente durante la scrittura del codice: essi possono essere determini durante l'esecuzione del programma semplicemente utilizzando delle variabili aggiuntive: ad esempio, il programma potrebbe chiedere all'utente quali debbano essere i valori di inizio e fine del contore e memorizzare questi valori in due variabili da usare nell'istruzione For:
Dim i as Integer 'contore
Dim intInizio as Integer, intFine as Integer 'valori iniziale e finale
intInizio=Val(InputBox("Inserisci il valore iniziale del contore:"))
intFine=Val(InputBox("Inserisci il valore finale del contore:"))
For i = intInizio To intFine
Debug.Print i
Next i
In questo esempio si è fto uso della funzione InputBox, che richiede all'utente l'inserimento di un valore in una casella di testo: tale valore è quello restituito dalla funzione, e poiché è di tipo stringa esso deve essere convertito in numero traverso la funzione Val. È chiaro che se l'utente inserisce nella casella un valore che non può essere convertito in numero (ad es. "a56bc"), sarà genero un errore causo dalla funzione Val.
Come per altri blocchi di istruzioni, anche per i blocchi For…Next è possibile usare la nidificazione, ovvero includere un blocco For all'interno di un altro blocco For:
For i = 1 To 10
For k = 5 To 22
[istruzioni]
Next k
Next i
La cosa importante è non intersecare mai due cicli distinti, ovvero non fare mai una cosa del genere:
For i = 1 To 10 'inizio PRIMO ciclo
For k = 5 To 22 'inizio SECONDO ciclo
[istruzioni]
Next i 'fine PRIMO ciclo
Next k 'fine SECONDO ciclo
Così facendo si genera un errore di sintassi, perché l'istruzione "Next i" non corrisponde all'istruzione "For k" che la precede: il secondo ciclo non è interamente contenuto nel primo, ma si sovrappone ad esso generando confusione. Volendo, è possibile anche omettere il nome del contore nell'istruzione Next, e in tal caso Visual Basic assumerà automicamente che esso si riferisce all'istruzione For immediamente precedente
For i = 1 To 10
For k = 5 To 22
[istruzioni]
Next ' Visual Basic assume che l'istruzione sia: Next k
Next ' Visual Basic assume che l'istruzione sia: Next i
Spesso è necessario interrompere l'esecuzione di un ciclo se si verifica una determina condizione: Visual Basic mette a disposizione del programmore un'istruzione apposita: Exit For, che sposta il punto di esecuzione del programma all'istruzione immediamente successiva all'istruzione Next reliva al ciclo interrotto. Solitamente questa istruzione si fa dipendere da un blocco If che controlla il verificarsi di una "condizione di uscita":
For i = 1 To 10
If i = 8 Then Exit For
Debug.Print i
Next i
Debug.Print "ciclo interrotto"
Il ciclo precedente, che semplicemente visualizza il valore del contore, teoricamente dovrebbe essere eseguito dieci volte ma in realtà è eseguito solo otto volte, perché all'ottava esecuzione la condizione i = 8 risulta verifica determinando l'uscita dal ciclo (senza stampare il valore del contore) e la visualizzazione del messaggio "ciclo interrotto"; si noti che questo messaggio sarebbe visualizzo in ogni caso, al termine del ciclo. I "puristi" della programmazione non vedono di buon occhio l'utilizzo dell'istruzione Exit For, perché in questo caso il ciclo non termina solo con l'ultima istruzione "Next", come ci si potrebbe aspettare in condizioni normali, ma potrebbe terminare anche all'interno del ciclo stesso: ciò determina un'eccezione alla normale esecuzione del codice e pertanto potrebbe complicarne la comprensione e la modifica.
In effetti utilizzare l'istruzione Exit For non è l'unico modo per interrompere un ciclo: sapendo che esso termina quando il contore supera il valore finale, la soluzione più intuitiva sarebbe quella di assegnare al contore un valore maggiore del limite finale in modo che il ciclo non prosegua oltre:
For i =1 To 10
If i = 8 then i =11
Debug.Print i
Next i
Debug.Print "ciclo interrotto"
Nell'esempio precedente, quando i=8 il programma assegna al contore il valore 11, cioè un valore superiore al limite di 10 specifico nell'istruzione For; in questo modo il ciclo non è interrotto direttamente, e infti l'istruzione Debug.Print i è eseguita normalmente anche quando i=8, però l'istruzione Next i verifica che il contore ha supero il limite e quindi determina la fine del ciclo e la visualizzazione del messaggio "ciclo interrotto". Tuttavia, da un punto di vista stilistico questa soluzione è ancora peggiore della precedente, perché il valore del contore non dovrebbe mai essere modifico direttamente all'interno del ciclo stesso: un metodo del genere può complicare molto il debug e l'eventuale modifica del codice perché può generare errori imprevisti e generalmente difficili da identificare.
Lezione 18
