Differenze tra le versioni di "Pascal/Istruzioni di controllo"

rilettura
(rilettura)
{{Programmare in Pascal}}
 
== Strutture di selezione ==
 
==If,= then,Selezione elsebinaria ===
In alcuni degli esempi precedenti si è analizzata la struttura ''if''...''then''...''else''; vediamo nello specifico in cosa consiste.<br/>
 
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:
In qualcuno degli esempi precedenti si è vista la sintassi con ''if'',''then'' e ''else'': vediamo in cosa consiste.
Nella pratica, questo costrutto consente la scelta fra due alternative: '''se''' (if) una certa condizione &egrave; vera '''allora''' (''then'') il programma esegue una certa istruzione, '''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 &egrave; 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):
<source lang=pascal>
'''if''' condizione '''then'''
if condizione then
''begin''
begin
istruzione 1;
istruzione 21;
istruzione ...2;
...
istruzione n
istruzione ''end''n
end
'''else'''
else
''begin''
begin
istruzione 1;
istruzione 21;
istruzione ...2;
...
istruzione n
istruzione n
''end'';
end;
 
</source>
Si noti come le istruzioni che precedono ''end'' o ''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
 
Facciamo un esempio pratico.<br/> Si vuole calcolare la radice quadrata di un numero: ci&ograve;ciò &egrave;è possibile nell'insieme dei numeri reali solo se il valore in ingresso &egrave;è positivo.
Il programma deve perci&ograve;perciò:
*acquisire il numero
*eseguire una selezione binaria: ''se'' il numero è positivo,''allora'' ne calcola la radice quadrata e espone il risultato;''altrimenti'' scrivestampa un messaggio di errore;
<source lang=pascal>
 
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
else writeln('La radice di un numero negativo non può essere espressa con numeri reali');
writeln('La radice di un numero negativo non può essere espressa con numeri reali');
readln;
readln; (* attenzione: questo readln non fa parte del blocco else! *)
end.
end.
 
</source>
==Case...of, else==
=== Selezione multipla ===
 
QuestoCon metodol'uso permettedel dicostrutto fare<code>case... of</code> è possibile eseguire scelteselezioni pi&ugrave;più complesse. La sintassi &egrave;è:
<source lang=pascal>
'''case''' selettoreespressione '''of'''
''valore 1'' : begin
istruzioni;
end;
''valore 2'' : begin
istruzioni;
end;
...
''valore n'' : begin
istruzioni
end;
''' else''' : begin
istruzioni;
end;
end;
</source>
 
Con il costrutto ''case'', il valore delladell'espressione variabilein selettoretesta 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 &egrave; compreso traeguaglia 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''.
 
Facciamo un esempio del costrutto case:
<source lang=pascal>
'''case''' Contatore '''of'''
case contatore of
1, 2, 50, 210: writeln(contatore);
1, 2, 50, 210: writeln(contatore);
30, 60..80 : begin
30, 60..80 : begin
writeln(variabile);
end writeln(variabile);
end;
'''end;'''
end;
alcune considerazioni sull'esempio proposto:
</source>
*&egrave; stata omesso il blocco facoltativo '''else'''
Ecco di seguito alcune considerazioni sull'esempio proposto:
*sono state scritte delle liste di possibili casi
*è 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 ==
<source lang=pascal>
 
for Contatore:=valore_iniziale to valore_finale do
 
begin
Questa struttura ci permette di ripetere una determinata serie di istruzioni per un numero finito di volte. La sua sintassi è:
istruzione 1;
 
istruzione 2;
'''for''' Contatore:=valore_iniziale '''to''' valore_finale '''do'''
...
begin
istruzione 1n;
end;
istruzione 2;
</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/>
istruzione n;
<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à.
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 e end.
Per Contatore s'intende una variabile (di solito vengono usate le lettere I,L,M,N,J,K) che da un valore iniziale cresce di un certo valore ogni ciclo d'istruzioni 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 è:
<source lang=pascal>
'''for''' contatore:=valore_iniziale '''downto''' valore_finale '''do'''
for Contatore:=valore_iniziale downto valore_finale do
begin
begin
istruzione 1;
istruzione 21;
istruzione 2;
...
...
istruzione n;
istruzione endn;
end;
 
</source>
Facciamo un esempio: scrivamo un programma che calcoli la somma dei primi n numeri naturali usando un ciclo for.<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:
*leggere n;
*tramite un ciclo for, sommare tutti i numeri da 1 a n;
*esporre il risultato.
<source lang=pascal>
 
program sommatoria;
var i,n,s:integer;
begin
s:=0;
writeln('Inserisci n');
readln(n);
for i:=1 to n do
begin s:=s+i;
s:=s+i;
end;
writeln('La somma dei primi n è ',s);
readln;
end.
</source>
 
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 &egrave; inizialmente uguale a 0;
*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 sarebbe successosuccede se n fosse stato,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.
*reinizia 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 ===
== While do ==
Una struttura di iterazione con condizione in testa è tradotta in Pascal con il ciclo '''while... do'''
Questo ciclo corrisponde ad una struttura decisionale a condizione in testa.
La sua sintassi è:
 
<source lang=pascal>
La sua sintassi &egrave;:
while condizione do
 
begin
'''while''' condizione '''do'''
istruzione 1;
'''begin'''
istruzione 12;
...
istruzione 2;
istruzione ...n;
end;
istruzione n;
</source>
'''end''';
Ovvero: '''mentre'''(''while'') una determinata condizione è vera '''esegui'''(''do'') le istruzioni all'interno del ciclo.<br/>
 
Fino a quando la condizione è vera, il ciclo viene eseguito.<br/>
Ovvero: '''mentre'''(while) una determinata condizione &egrave; vera '''esegui'''(do) le istruzioni all'interno del ciclo.
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.
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&agrave; della condizione. Questo &egrave; molto importante perch&eacute; altrimenti il ciclo si ripeterebbe all'infinito e il programma non riuscirebbe mai a giungere alle righe che seguono l'istruzione '''end'''. Questo &egrave; un comune errore che con un po' di attenzione pu&ograve; essere evitato. Se vi è una sola istruzione '''begin''' e '''end''' possono essere omessi.
 
Ad esempio
<source lang=pascal>
 
...
x:=1;
'''while''' x<>5 '''do'''
x:=x+1;
...
</source>
 
In questo esempio viene eseguito quanto scrittoindicato 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 ===
==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'''
Dopo aver parlato di If...Then, Else, e dei cicli For e While Do, chiudiamo il discorso sui cicli con Repeat...Until.
 
La sua sintassi e':
<source lang=pascal>
repeat
...
begin
'''Repeat'''
istruzione 1;
istruzione 2;
...
istruzione n;
end;
'''Until''' condizione;
until condizione;
...
</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.
 
Ad esempio:
<source lang=pascal>
 
x:=1;
...
repeat
x:=1;
x:=x+1;
repeat
until x:=x+15;
</source>
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.
 
=== For,Un While,confronto Repeat Until===
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&eacute; 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&ograve; risultare utile in particolari casi mentre in altri pu&ograve; essere causa di bug.
&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.
 
[[Categoria:Programmare in Pascal|Istruzioni di controllo]]
8 469

contributi