Pascal/Istruzioni di controllo: differenze tra le versioni

Wikibooks, manuali e libri di testo liberi.
Contenuto cancellato Contenuto aggiunto
BimBot (discussione | contributi)
m Robot: Changing template: Programmare in Pascal
The Doc (discussione | contributi)
Nessun oggetto della modifica
Riga 2: Riga 2:


== Strutture di selezione ==
== Strutture di selezione ==

=== Selezione binaria ===
=== Selezione binaria ===

In alcuni degli esempi precedenti si è analizzata la struttura ''if''...''then''...''else''; vediamo nello specifico in cosa consiste.<br/>
In alcuni degli esempi precedenti si è analizzata la struttura ''if''...''then''...''else''; vediamo nello specifico in cosa consiste.

Nella pratica, questo costrutto consente la scelta fra due alternative: '''se''' (''if'') una certa condizione è vera '''allora''' (''then'') il programma esegue una certa istruzione (semplice o composta), '''altrimenti''' (''else'') ne esegue un'altra:
Nella pratica, questo costrutto consente la scelta fra due alternative: '''se''' (''if'') una certa condizione è vera '''allora''' (''then'') il programma esegue una certa istruzione (semplice o composta), '''altrimenti''' (''else'') ne esegue un'altra:
'''if''' condizione '''then''' istruzione
'''if''' condizione '''then''' istruzione
'''else''' istruzione;
'''else''' istruzione;
che come abbiamo già visto permette la scelta fra un caso vero e un caso falso e in base a questo esegue il contenuto del ''then'' o dell'''else''; tuttavia a volte il ramo in ''else'' non &egrave; strettamente utile o addirittura non serve.
che come abbiamo già visto permette la scelta fra un caso vero e un caso falso e in base a questo esegue il contenuto del ''then'' o dell'''else''; tuttavia a volte il ramo in ''else'' non é; strettamente utile o addirittura non serve.


Quando le istruzioni che seguono il ''then'' o l'''else'' sono più di una esse devono essere delimitate da istruzioni ''begin'' e ''end'' (sono istruzioni composte):
Quando le istruzioni che seguono il ''then'' o l'''else'' sono più di una esse devono essere delimitate da istruzioni ''begin'' e ''end'' (sono istruzioni composte):

<source lang=pascal>
<source lang=pascal>
if condizione then
if condizione then
Riga 26: Riga 30:
end;
end;
</source>
</source>

Si noti come le istruzioni che precedono ''end'' ed ''else'' non debbano essere seguite da punto e virgola
Si noti come le istruzioni che precedono ''end'' ed ''else'' non debbano essere seguite da punto e virgola


Riga 32: Riga 37:
*acquisire il numero
*acquisire il numero
*eseguire una selezione binaria: ''se'' il numero è positivo,''allora'' ne calcola la radice quadrata e espone il risultato;''altrimenti'' stampa un messaggio di errore;
*eseguire una selezione binaria: ''se'' il numero è positivo,''allora'' ne calcola la radice quadrata e espone il risultato;''altrimenti'' stampa un messaggio di errore;

<source lang=pascal>
<source lang=pascal>
program radice_quadrata;
program radice_quadrata;
Riga 48: Riga 54:
end.
end.
</source>
</source>

=== Selezione multipla ===
=== Selezione multipla ===

Con l'uso del costrutto <code>case... of</code> è possibile eseguire selezioni più complesse. La sintassi è:
Con l'uso del costrutto <code>case... of</code> è possibile eseguire selezioni più complesse. La sintassi è:

<source lang=pascal>
<source lang=pascal>
case espressione of
case espressione of
Riga 69: Riga 78:
end;
end;
</source>
</source>

Con il costrutto ''case'', il valore dell'espressione in testa viene confrontato con il valore di ogni singolo caso; quando viene trovato un valore che soddisfa le condizioni sul selettore vengono eseguite le istruzioni relative al blocco in questione; poi il controllo passa alla prima istruzione dopo il costrutto ''case''.
Con il costrutto ''case'', il valore dell'espressione in testa viene confrontato con il valore di ogni singolo caso; quando viene trovato un valore che soddisfa le condizioni sul selettore vengono eseguite le istruzioni relative al blocco in questione; poi il controllo passa alla prima istruzione dopo il costrutto ''case''.
Se nessun valore soddisfa il selettore viene eseguita l'ultimo blocco di istruzioni individuato dalla parola chiave '''else''' (se questo blocco è stato inserito). Se la parte con ''else'' viene omessa e il selettore non eguaglia nessuno dei casi in elenco, si passa anche in questo caso alla prima istruzione dopo il costrutto ''case''.
Se nessun valore soddisfa il selettore viene eseguita l'ultimo blocco di istruzioni individuato dalla parola chiave '''else''' (se questo blocco è stato inserito). Se la parte con ''else'' viene omessa e il selettore non eguaglia nessuno dei casi in elenco, si passa anche in questo caso alla prima istruzione dopo il costrutto ''case''.

<br/>Quando c'è solo un istruzione che segue un certo caso si possono omettere ''begin'' e ''end'' (questo perché, in realtà, le istruzioni delimitate da begin ed end si possono considerare come un'unica istruzione).<br/>Occorre fare attenzione che il costrutto ''case'' termina con un ''end''.
Quando c'è solo un istruzione che segue un certo caso si possono omettere ''begin'' e ''end'' (questo perché, in realtà, le istruzioni delimitate da begin ed end si possono considerare come un'unica istruzione).

Occorre fare attenzione che il costrutto ''case'' termina con un ''end''.
Facciamo un esempio del costrutto case:
Facciamo un esempio del costrutto case:

<source lang=pascal>
<source lang=pascal>
case contatore of
case contatore of
Riga 81: Riga 95:
end;
end;
</source>
</source>

Ecco di seguito alcune considerazioni sull'esempio proposto:
Ecco di seguito alcune considerazioni sull'esempio proposto:
*è stata omesso il blocco facoltativo '''else'''
*è stata omesso il blocco facoltativo '''else'''
Riga 87: Riga 102:


== Strutture Iterative ==
== Strutture Iterative ==

In Pascal abbiamo diversi tipi di strutture iterative (in genere vengono detti "''cicli''"). Una struttura iterativa prevede la ripetizione di un'istruzione semplice o composta secondo delle condizioni poste all'inizio o alla fine della struttura.
In Pascal abbiamo diversi tipi di strutture iterative (in genere vengono detti "''cicli''"). Una struttura iterativa prevede la ripetizione di un'istruzione semplice o composta secondo delle condizioni poste all'inizio o alla fine della struttura.

=== Iterazione con contatore ===
=== Iterazione con contatore ===

Questa struttura ci permette di ripetere una determinata serie di istruzioni per un numero finito di volte modificando man mano il valore di una variabile. La sua sintassi è:
Questa struttura ci permette di ripetere una determinata serie di istruzioni per un numero finito di volte modificando man mano il valore di una variabile. La sua sintassi è:

<source lang=pascal>
<source lang=pascal>
for Contatore:=valore_iniziale to valore_finale do
for Contatore:=valore_iniziale to valore_finale do
Riga 99: Riga 118:
end;
end;
</source>
</source>

Nella pratica questo costrutto consente la ripetizione di un certo gruppo di istruzioni fino a quando la variabile contatore raggiunge un certo valore: '''per''' (''for''') contatore:=valore_iniziale '''fino a''' (''to'') valore_finale '''esegui''' (''do'') un blocco d'istruzioni racchiuso tra begin ed end.<br/>
Nella pratica questo costrutto consente la ripetizione di un certo gruppo di istruzioni fino a quando la variabile contatore raggiunge un certo valore: '''per''' (''for''') contatore:=valore_iniziale '''fino a''' (''to'') valore_finale '''esegui''' (''do'') un blocco d'istruzioni racchiuso tra ''begin'' ed ''end''.

<code>Contatore</code> è una variabile (di solito vengono usate le lettere I,L,M,N,J,K) che da un valore iniziale cresce di un certo valore ad ogni ripetizione fino a che non raggiunge il valore finale, che rappresenta il valore per il quale il ciclo terminerà.
<code>Contatore</code> è una variabile (di solito vengono usate le lettere I,L,M,N,J,K) che da un valore iniziale cresce di un certo valore ad ogni ripetizione fino a che non raggiunge il valore finale, che rappresenta il valore per il quale il ciclo terminerà.


L'iterazione può anche procedere in modo che la variabile contatore decresca a ogni ciclo; in questo caso la sintassi è:
L'iterazione può anche procedere in modo che la variabile contatore decresca a ogni ciclo; in questo caso la sintassi è:

<source lang=pascal>
<source lang=pascal>
for Contatore:=valore_iniziale downto valore_finale do
for Contatore:=valore_iniziale downto valore_finale do
Riga 112: Riga 134:
end;
end;
</source>
</source>

Facciamo un esempio: implementiamo un programma che calcoli la somma dei primi n numeri naturali usando un ciclo <code>for</code> (senza usare la nota formula <math>\frac{n + (n + 1)}{2}</math>).<br/>
Facciamo un esempio: implementiamo un programma che calcoli la somma dei primi n numeri naturali usando un ciclo <code>for</code> (senza usare la nota formula <math>\frac{n + (n + 1)}{2}</math>).<br/>
Il programma deve:
Il programma deve:
Riga 117: Riga 140:
*tramite un ciclo for, sommare tutti i numeri da 1 a n;
*tramite un ciclo for, sommare tutti i numeri da 1 a n;
*esporre il risultato.
*esporre il risultato.

<source lang=pascal>
<source lang=pascal>
program sommatoria;
program sommatoria;
Riga 130: Riga 154:
end.
end.
</source>
</source>

Analizziamo il programma riga per riga:
Analizziamo il programma riga per riga:
*dichiarazione del programma;
*dichiarazione del programma;
*dichiarazione delle variabili: i è la variabile contatore, n funge da valore finale del ciclo for, q è di volta in volta il quadrato di i mentre s è la somma dei numeri naturali fino a n;
*dichiarazione delle variabili: i è la variabile contatore, n funge da valore finale del ciclo for, q è di volta in volta il quadrato di i mentre s è la somma dei numeri naturali fino a n;
*inizio del programma
*inizio del programma
*la somma &egrave; inizialmente uguale a 0;
*la somma é inizialmente uguale a 0;
*messaggio di testo;
*messaggio di testo;
*il programma legge n;
*il programma legge n;
Riga 145: Riga 170:
*i := 2, diverso da 50, quindi il ciclo continua;
*i := 2, diverso da 50, quindi il ciclo continua;
*s := s + i, cioè s:=1+2; infatti la variabile s aveva valore 1 alla fine della prima fase del ciclo.
*s := s + i, cioè s:=1+2; infatti la variabile s aveva valore 1 alla fine della prima fase del ciclo.
*reinizia il ciclo; i:=3,diverso da 50,quindi il ciclo continua;
*ricomincia il ciclo; i:=3,diverso da 50,quindi il ciclo continua;
*s := s + 1;cioè s := 3 + 3;
*s := s + 1;cioè s := 3 + 3;
*e così via, fino a quando i sia diverso da 50.
*e così via, fino a quando i sia diverso da 50.


=== Iterazione con condizione in testa ===
=== Iterazione con condizione in testa ===

Una struttura di iterazione con condizione in testa è tradotta in Pascal con il ciclo '''while... do'''
Una struttura di iterazione con condizione in testa è tradotta in Pascal con il ciclo '''while... do'''
La sua sintassi è:
La sua sintassi è:

<source lang=pascal>
<source lang=pascal>
while condizione do
while condizione do
Riga 161: Riga 188:
end;
end;
</source>
</source>

Ovvero: '''mentre'''(''while'') una determinata condizione è vera '''esegui'''(''do'') le istruzioni all'interno del ciclo.<br/>
Ovvero: '''mentre'''(''while'') una determinata condizione è vera '''esegui'''(''do'') le istruzioni all'interno del ciclo.
Fino a quando la condizione è vera, il ciclo viene eseguito.<br/>

Fino a quando la condizione è vera, il ciclo viene eseguito.
Tra '''begin''' ed '''end''' vanno inserite le istruzioni che cambiano in qualche modo il valore di verità della condizione. Questo è molto importante perché altrimenti il ciclo si ripeterebbe all'infinito e il programma non riuscirebbe mai a giungere alle righe che seguono l'istruzione '''end'''. Questo è un comune errore che con un po' di attenzione può essere evitato. Se vi è una sola istruzione '''begin''' e '''end''' possono essere omessi.
Tra '''begin''' ed '''end''' vanno inserite le istruzioni che cambiano in qualche modo il valore di verità della condizione. Questo è molto importante perché altrimenti il ciclo si ripeterebbe all'infinito e il programma non riuscirebbe mai a giungere alle righe che seguono l'istruzione '''end'''. Questo è un comune errore che con un po' di attenzione può essere evitato. Se vi è una sola istruzione '''begin''' e '''end''' possono essere omessi.
Ad esempio
Ad esempio:

<source lang=pascal>
<source lang=pascal>
...
...
Riga 172: Riga 202:
...
...
</source>
</source>

In questo esempio viene eseguito quanto indicato all'interno del ciclo finché viene verificata la condizione, cioè ad x viene sommato 1 fino a che il suo valore non sia uguale a 5,e quindi la condizione iniziale del ciclo diventi falsa.
In questo esempio viene eseguito quanto indicato all'interno del ciclo finché viene verificata la condizione, cioè ad x viene sommato 1 fino a che il suo valore non sia uguale a 5,e quindi la condizione iniziale del ciclo diventi falsa.


=== Iterazione con condizione finale ===
=== Iterazione con condizione finale ===

Per chiudere il discorso riguardo alle strutture di controllo analizziamo il ciclo con condizione finale, che in Pascal si traduce con un ciclo '''repeat... until'''
Per chiudere il discorso riguardo alle strutture di controllo analizziamo il ciclo con condizione finale, che in Pascal si traduce con un ciclo '''repeat... until'''


La sua sintassi e':
La sua sintassi e':

<source lang=pascal>
<source lang=pascal>
repeat
repeat
Riga 188: Riga 221:
until condizione;
until condizione;
</source>
</source>

In sostanza questo ciclo ripete le istruzioni comprese tra Repeat ed Until (dall'inglese,''finché'') fino al verificarsi della condizione espressa, detta anche condizione di uscita. Anche in questo caso occorre porre attenzione al fatto che la condizione di uscita diventi vera in qualche modo, altrimenti finiamo in un loop infinito perdendo il controllo del programma.
In sostanza questo ciclo ripete le istruzioni comprese tra ''Repeat'' ed ''Until'' (dall'inglese,''finché'') fino al verificarsi della condizione espressa, detta anche condizione di uscita. Anche in questo caso occorre porre attenzione al fatto che la condizione di uscita diventi vera in qualche modo, altrimenti finiamo in un loop infinito perdendo il controllo del programma.


Ad esempio:
Ad esempio:

<source lang=pascal>
<source lang=pascal>
x:=1;
x:=1;
Riga 197: Riga 232:
until x=5;
until x=5;
</source>
</source>

In questo caso x viene sommato a 1 fino a che il suo valore non sia diverso da 5; quando x=5 si esce dal ciclo.
In questo caso x viene sommato a 1 fino a che il suo valore non sia diverso da 5; quando x=5 si esce dal ciclo.


=== Un confronto ===
=== Un confronto ===

Nel caso del ciclo '''For''' il numero di cicli eseguiti è noto, poiché il contatore parte da un elemento iniziale ed arriva fino all'elemento finale. Nel caso di '''While''' e di '''Repeat Until''' il numero di volte che viene ripetuto il ciclo generalmente non è noto a priori, in quanto dipende dal cambiamento che subisce la variabile che controlla la condizione.
Nel caso del ciclo '''For''' il numero di cicli eseguiti è noto, poiché il contatore parte da un elemento iniziale ed arriva fino all'elemento finale. Nel caso di '''While''' e di '''Repeat Until''' il numero di volte che viene ripetuto il ciclo generalmente non è noto a priori, in quanto dipende dal cambiamento che subisce la variabile che controlla la condizione.


&Egrave; da notare che le istruzioni del ciclo '''Repeat Until''' verranno eseguite almeno una volta poichè la condizione viene verificata alla fine, dopo il codice del ciclo; un ciclo '''While''', essendo la sua condizione testata prima dell'esecuzione del codice associato al ciclo, potrebbe, se questa risulta falsa, non fare nulla e riprendere dalle istruzioni che si trovano dopo il ciclo. Questo può risultare utile in particolari casi come in altri può essere causa di bug.
È importante notare che le istruzioni del ciclo '''Repeat Until''' verranno eseguite almeno una volta poiché la condizione viene verificata alla fine, dopo il codice del ciclo; un ciclo '''While''', essendo la sua condizione testata prima dell'esecuzione del codice associato al ciclo, potrebbe, se questa risulta falsa, non fare nulla e riprendere dalle istruzioni che si trovano dopo il ciclo. Questo può risultare utile in particolari casi come in altri può essere causa di bug.


[[Categoria:Pascal|Istruzioni di controllo]]
[[Categoria:Pascal|Istruzioni di controllo]]

Versione delle 22:36, 6 giu 2007

Indice del libro

Strutture di selezione

Selezione binaria

In alcuni degli esempi precedenti si è analizzata la struttura if...then...else; vediamo nello specifico in cosa consiste.

Nella pratica, questo costrutto consente la scelta fra due alternative: se (if) una certa condizione è vera allora (then) il programma esegue una certa istruzione (semplice o composta), altrimenti (else) ne esegue un'altra:

if condizione  then istruzione
       else istruzione;

che come abbiamo già visto permette la scelta fra un caso vero e un caso falso e in base a questo esegue il contenuto del then o dell'else; tuttavia a volte il ramo in else non é; strettamente utile o addirittura non serve.

Quando le istruzioni che seguono il then o l'else sono più di una esse devono essere delimitate da istruzioni begin e end (sono istruzioni composte):

if condizione then
begin
    istruzione 1;
    istruzione 2;
    ...
    istruzione n
end
else
begin
    istruzione 1;
    istruzione 2;
    ...
    istruzione n
end;

Si noti come le istruzioni che precedono end ed else non debbano essere seguite da punto e virgola

Facciamo un esempio pratico.
Si vuole calcolare la radice quadrata di un numero: ciò è possibile nell'insieme dei numeri reali solo se il valore in ingresso è positivo. Il programma deve perciò:

  • acquisire il numero
  • eseguire una selezione binaria: se il numero è positivo,allora ne calcola la radice quadrata e espone il risultato;altrimenti stampa un messaggio di errore;
program radice_quadrata;
    var n,r:real;
begin
    writeln('Inserisci un numero positivo');
    readln(n);
    if n>=0 then
    begin
       r:=sqrt(n);
       writeln('La radice quadrata del numero inserito &egrave; ',r:8:3);
    end
    else
       writeln('La radice di un numero negativo non può essere espressa con numeri reali');
    readln; (* attenzione: questo readln non fa parte del blocco else! *)
end.

Selezione multipla

Con l'uso del costrutto case... of è possibile eseguire selezioni più complesse. La sintassi è:

case espressione of
     valore 1 : begin 
                    istruzioni;
                end;
     valore 2 : begin
                    istruzioni;
                end;
     ... 
     
     valore n : begin
                    istruzioni
                 end; 
  
     else      : begin
                    istruzioni;
                 end;
end;

Con il costrutto case, il valore dell'espressione in testa viene confrontato con il valore di ogni singolo caso; quando viene trovato un valore che soddisfa le condizioni sul selettore vengono eseguite le istruzioni relative al blocco in questione; poi il controllo passa alla prima istruzione dopo il costrutto case. Se nessun valore soddisfa il selettore viene eseguita l'ultimo blocco di istruzioni individuato dalla parola chiave else (se questo blocco è stato inserito). Se la parte con else viene omessa e il selettore non eguaglia nessuno dei casi in elenco, si passa anche in questo caso alla prima istruzione dopo il costrutto case.

Quando c'è solo un istruzione che segue un certo caso si possono omettere begin e end (questo perché, in realtà, le istruzioni delimitate da begin ed end si possono considerare come un'unica istruzione).

Occorre fare attenzione che il costrutto case termina con un end. Facciamo un esempio del costrutto case:

case contatore of
  1, 2, 50, 210: writeln(contatore);
  30, 60..80 : begin
                 writeln(variabile); 
               end;
end;

Ecco di seguito alcune considerazioni sull'esempio proposto:

  • è stata omesso il blocco facoltativo else
  • sono state indicate delle liste di possibili casi
  • è stato usato un range di valori x..y; al terzo rigo,60..80 indica tutti i valori compresi tra 60 e 80 (inclusi).

Strutture Iterative

In Pascal abbiamo diversi tipi di strutture iterative (in genere vengono detti "cicli"). Una struttura iterativa prevede la ripetizione di un'istruzione semplice o composta secondo delle condizioni poste all'inizio o alla fine della struttura.

Iterazione con contatore

Questa struttura ci permette di ripetere una determinata serie di istruzioni per un numero finito di volte modificando man mano il valore di una variabile. La sua sintassi è:

for Contatore:=valore_iniziale to valore_finale do
begin
  istruzione 1;
  istruzione 2;
  ...
  istruzione n;
end;

Nella pratica questo costrutto consente la ripetizione di un certo gruppo di istruzioni fino a quando la variabile contatore raggiunge un certo valore: per (for) contatore:=valore_iniziale fino a' (to) valore_finale esegui (do) un blocco d'istruzioni racchiuso tra begin ed end.

Contatore è una variabile (di solito vengono usate le lettere I,L,M,N,J,K) che da un valore iniziale cresce di un certo valore ad ogni ripetizione fino a che non raggiunge il valore finale, che rappresenta il valore per il quale il ciclo terminerà.

L'iterazione può anche procedere in modo che la variabile contatore decresca a ogni ciclo; in questo caso la sintassi è:

for Contatore:=valore_iniziale downto valore_finale do
begin
  istruzione 1;
  istruzione 2;
  ...
  istruzione n;
end;

Facciamo un esempio: implementiamo un programma che calcoli la somma dei primi n numeri naturali usando un ciclo for (senza usare la nota formula ).
Il programma deve:

  • leggere n;
  • tramite un ciclo for, sommare tutti i numeri da 1 a n;
  • esporre il risultato.
program sommatoria;
    var i,n,s:integer;
begin
    s:=0;
    writeln('Inserisci n');
    readln(n);
    for i:=1 to n do
        s:=s+i;
    writeln('La somma dei primi n è ',s);
    readln;
end.

Analizziamo il programma riga per riga:

  • dichiarazione del programma;
  • dichiarazione delle variabili: i è la variabile contatore, n funge da valore finale del ciclo for, q è di volta in volta il quadrato di i mentre s è la somma dei numeri naturali fino a n;
  • inizio del programma
  • la somma é inizialmente uguale a 0;
  • messaggio di testo;
  • il programma legge n;
  • il ciclo for: per i uguale a 1 fino a che i non sia uguale a n,esegue il gruppo d'istruzioni:
  • inizio del ciclo;
  • alla variabile s viene assegnata la somma del valore di s+i; prima del ciclo s era uguale a 0, quindi s:=1;
  • fine del ciclo: se i è diverso da n, il ciclo viene riavviato; altrimenti si prosegue all'istruzione successiva. Automaticamente alla fine del ciclo i viene incrementato di 1.

Vediamo cosa succede se n assume ad esempio il valore 50:

  • i := 2, diverso da 50, quindi il ciclo continua;
  • s := s + i, cioè s:=1+2; infatti la variabile s aveva valore 1 alla fine della prima fase del ciclo.
  • ricomincia il ciclo; i:=3,diverso da 50,quindi il ciclo continua;
  • s := s + 1;cioè s := 3 + 3;
  • e così via, fino a quando i sia diverso da 50.

Iterazione con condizione in testa

Una struttura di iterazione con condizione in testa è tradotta in Pascal con il ciclo while... do La sua sintassi è:

while condizione do
begin
    istruzione 1;
    istruzione 2;
    ...
    istruzione n;
end;

Ovvero: mentre(while) una determinata condizione è vera esegui(do) le istruzioni all'interno del ciclo.

Fino a quando la condizione è vera, il ciclo viene eseguito. Tra begin ed end vanno inserite le istruzioni che cambiano in qualche modo il valore di verità della condizione. Questo è molto importante perché altrimenti il ciclo si ripeterebbe all'infinito e il programma non riuscirebbe mai a giungere alle righe che seguono l'istruzione end. Questo è un comune errore che con un po' di attenzione può essere evitato. Se vi è una sola istruzione begin e end possono essere omessi. Ad esempio:

...
x:=1;
while x<>5 do
    x:=x+1;
...

In questo esempio viene eseguito quanto indicato all'interno del ciclo finché viene verificata la condizione, cioè ad x viene sommato 1 fino a che il suo valore non sia uguale a 5,e quindi la condizione iniziale del ciclo diventi falsa.

Iterazione con condizione finale

Per chiudere il discorso riguardo alle strutture di controllo analizziamo il ciclo con condizione finale, che in Pascal si traduce con un ciclo repeat... until

La sua sintassi e':

 
repeat
begin
    istruzione 1; 
    istruzione 2;
    ... 
    istruzione n
end;
until condizione;

In sostanza questo ciclo ripete le istruzioni comprese tra Repeat ed Until (dall'inglese,finché) fino al verificarsi della condizione espressa, detta anche condizione di uscita. Anche in questo caso occorre porre attenzione al fatto che la condizione di uscita diventi vera in qualche modo, altrimenti finiamo in un loop infinito perdendo il controllo del programma.

Ad esempio:

x:=1;
repeat
x:=x+1;
until x=5;

In questo caso x viene sommato a 1 fino a che il suo valore non sia diverso da 5; quando x=5 si esce dal ciclo.

Un confronto

Nel caso del ciclo For il numero di cicli eseguiti è noto, poiché il contatore parte da un elemento iniziale ed arriva fino all'elemento finale. Nel caso di While e di Repeat Until il numero di volte che viene ripetuto il ciclo generalmente non è noto a priori, in quanto dipende dal cambiamento che subisce la variabile che controlla la condizione.

È importante notare che le istruzioni del ciclo Repeat Until verranno eseguite almeno una volta poiché la condizione viene verificata alla fine, dopo il codice del ciclo; un ciclo While, essendo la sua condizione testata prima dell'esecuzione del codice associato al ciclo, potrebbe, se questa risulta falsa, non fare nulla e riprendere dalle istruzioni che si trovano dopo il ciclo. Questo può risultare utile in particolari casi come in altri può essere causa di bug.