Strutture di programmazione

Le strutture di programmazione nel Pascal sono tre:

1) Struttura sequenziale: lesecuzione procede in forma lineare una istruzione

dopo laltra;
2) Struttura iterativa (cicli): fordo (definito, enumerativo); repeatuntil
(indefinito), while (indefinito);
3) Struttura selettiva: ifthenelse, caseof

Struttura selettiva ad una via

Questa consente di ripetere listruzione o il blocco di istruzioni quando la condizione
stabilita vera. Se la condizione falsa listruzione o il blocco di istruzioni viene
ignorato. Sotto la sintassi corretta:

Sintassi1 Sintassi2
if condizione then if condizione then
istruzione; begin
istruzione1;
istruzione2;
istruzioneN
end;

Le istruzioni, se sono pi di una, devono essere racchiuse tra le parole chiavi begin ad
end; dopo il begin oppure il then se ce una sola istruzione possono essere inseriti altre
strutture di flusso delle informazioni come un altro ifthen o un ciclo fordo;

if condizione then if condizione then

for i:=1 to 100 do repeat
begin .
.. until
end;
La condizione unespressione che una volta valutata deve generare un valore
booleano (Vero/Falso); le condizioni si esprimono con gli operatori relazionali.
Gli operatori relazionali sono: >; <; >=; <=; =; <>;

Tabella 1 Esercizio sconto

(* intestazione *) (* parte esecutiva *)

program sconto; begin
(* parte dichiarativa *) writeln(Inserisci prezzo prodotto)
uses crt; readln( prezzo );
var writeln(Inserisci percentuale sconto);
prezzo: real; readln( percentuale_sconto);
tipo_cliente: string; writeln(Inserisci tipo cliente);
percentuale_sconto: integer; readln( tipo_cliente);
if tipo_cliente=abituale then
prezzo := prezzo (prezzo/100) *
percentuale_sconto;
writeln(Questo cliente paga: ,prezzo);
writeln(Premi invio per continuare);
readln;
end.
Struttura selettiva a due vie
Rispetto quella ad una via viene aggiunta la parte da eseguire quando la condizione
falsa. In questo caso se la condizione vera viene eseguita listruzione o il blocco di
istruzioni; se la condizione falsa viene ignorata listruzione o il blocco di istruzioni
(tra begin ed end) dopo il then e viene eseguita la parte else

Tabella 2 Sintassi condizione a due vie

if condizione then if condizione then if condizione then if condizione then

istruzioneSeVera
else
istruzioneSeFalsa;
In questo esempio ce
una sola istruzione da
seguire sia che la
condizione sia vera sia
che sia falsa;
begin istruzioneSeVera begin
istruzione1SeVera; else istruzione1SeVera;
istruzione2SeVera; begin istruzione2SeVera;
istruzione1SeFalsa;
IstruzioneNSeVera; istruzione2SeFalsa; istruzioneNSeVera;
end end
else IstruzioneNSeFalsa; else
istruzioneSeFalsa; end; begin
istruzione1SeFalsa;
Qui abbiamo N Qui ce una sola istruzione2SeFalsa;
istruzione da seguire istruzione da seguire
se la condizione vera se vera ed N istruzioneNSeFalsa;
ed una sola se la istruzioni se falsa; end;
condizione falsa;
Qui ce pi di una
istruzione da seguire
sia che sia vera sia che
sia falsa;

Non mettere mai il punto e virgola (;) prima dellelse.

Le condizioni usate fino ad ora sono dette semplici;
Se usiamo invece i connettivi logici and, or, not possiamo comporre delle condizioni
pi complesse o composte;

Quando usiamo and la condizione composta vera quando sono vere tutte le
condizioni coinvolte; anche se una di esse falsa tutte le condizioni sono false.
Tabella 3 connettivo logico and

If (a>=1) and (a<3) then Le parentesi sono obbligatorie;

writeln(a ecompreso tra 1 e 3); Per inserire un apostrofo o un accento in una
stringa necessario raddoppiarlo;
if(s1=rossi) and (eta>=18) then le condizioni possono essere pi di due basta che
writeln(rossi e maggiorenne, maschio o siano vere tutte;
femmina);
Quando usiamo or la condizione composta vera quando vera almeno una delle
condizioni coinvolte; falsa quanto le condizioni sono contemporaneamente false.

Tabella 4 connettivo logico or

if (mese=Gennaio) or (mese=Marzo) or Le parentesi sono obbligatorie;

(mese=Luglio) then Per inserire un apostrofo o un accento in una
Numero_giorni := 31; stringa necessario raddoppiarlo;

Vi sono poi delle situazioni particolari come ad esempio il caso in cui le istruzioni da
seguire siamo pi di una o nel caso di if nidificati o if in cascata.
Tabella 5 Piu di 1 istruzione da seguire, if nidificati e if in cascata

if (s1='bella') or ( (eta>60) and (* troviamo il massimo tra a b c IF in cascata:

(s2='ricca') ) then *)
begin if a>=b then if condizione1 then
writeln('la sposo in ogni caso if a>=c then
...'); writeln('il max e'' a') else
writeln('poi forse mi pentiro!') else if condizione2 then
end writeln('il max e'' c')
else else else
begin if b>=c then if condizione3 then
writeln('in questo caso niente writeln('il max e'' b') .
dubbi ...'); else else
writeln('... meglio scapoli !!'); writeln('il max e'' c');
Vediamo un esempio concreto di selezione ad una via con un programma che simula
il lancio dei dadi.
Tabella 6 Gioco dadi: selezione ad una via

(* intestazione programma *) Questa consente di ripetere listruzione o il

program dadi blocco di istruzioni quando la condizione
(* parte dichiarativa *) stabilita vera. Se la condizione falsa
uses crt; listruzione o il blocco di istruzioni viene
const ignorato.
MAX_PUNTATA=100; Nella sezione const ho introdotto la costante
var massima puntata che si pu fare; le variabili
soldi, puntata, dado: integer; sono i soldi che il giocatore possiede e il dado ci
risposta: char; serve per simulare il lancio dove usciranno
(* parte esecutiva *) numeri casuali utilizzando il comando random;
begin dopo aver inizializzato le variabili e scritto con
clrscr; quanti soldi il giocatore vuole partire (budget)
soldi :=0; puntata :=0; dado:=0; risposta:= ; tutto si concentra sul ciclo repeat. Stabilisco le
writeln(Con quanti soldi vuoi partire); regole che si vince a partire da 4, e se si perde
readln(soldi); non si perdono soldi; quindi si chiede quanto si
punta si lancia il dado e se il numero del dado e
repeat >= a 4 si vince. Poi arriva la risposta se si vuole
writeln(Quanto punti ?); giocare ancora e si risponde; la condizione di
readln (puntata ); terminazione del gioco e se si risponde N;
dado:= random(6) + 1; A fine programma ci si limita a scrivere quanti
writeln(E uscito: ,dado); soldi sono avanzati.
if dado>=4 then Ora per migliorare il programma dopo dado
soldi := soldi + puntata; rendiamo evidente il numero uscito con una
writeln(Vuoi giocare ancora ? (S/N) ); writeln e il valore dado;
readln( risposta ); upcase quel comando che traduce il carattere
until upcase (risposta) =N; automaticamente da minuscolo a maiuscolo.
writeln(Hai terminato con questi soldi: ,soldi);
writeln(Premi invio per continuare);
readln;
end.

Ora chiediamo al nostro programma chiediamo se il giocatore ha vinto quindi il dado

supera o uguaglia 4 di mostrarlo a video. Le istruzioni diventano pi di una quindi la
struttura cambia perch le istruzioni vanno racchiuse dentro un begin.end;
Tabella 7 Gioco dadi: selezione ad una via begin...end

(* intestazione programma *) Qui la condizione if si arricchisce del begin e del

program dadi end perch chiediamo al programma se il
(* parte dichiarativa *) giocatore ha vinto e quanti soldi ha dopo la
uses crt; vittoria.
const Ora miglioriamo il programma chiedendo
MAX_PUNTATA=100; che quando il giocatore perde i soldi
var diminuiscono; a questo punto le condizioni
soldi, puntata, dado: integer; diventano due perch due sono le possibilit
risposta: char; o si vince o si perde quindi cambia la
(* parte esecutiva *) struttura selettiva che passa da una via a due
begin vie.
clrscr;
soldi :=0; puntata :=0; dado:=0; risposta:= ;
writeln(Con quanti soldi vuoi partire);
readln(soldi);

repeat
writeln(Quanto punti ?);
readln (puntata );
dado:= random(6) + 1;
writeln(E uscito: ,dado);
if dado>=4 then
begin
soldi := soldi + puntata;
writeln(Complimenti !! Hai vinto !!! );
writeln(Possiedi ora , soldi, euro.)
end;
writeln(Vuoi giocare ancora ? (S/N) );
readln( risposta );
until upcase (risposta) =N;
writeln(Hai terminato con questi soldi: ,soldi);
writeln(Premi invio per continuare);
readln;
end.
Vediamo come la struttura cambia quando la struttura selettiva e a due vie:

Tabella 8 Gioco dadi: selezione a due vie

(* intestazione programma *) Rispetto quella ad una via viene aggiunta la

program dadi parte da eseguire quando la condizione
(* parte dichiarativa *) falsa. In questo caso se la condizione vera
uses crt; viene eseguita listruzione o il blocco di
const istruzioni; se la condizione falsa viene
MAX_PUNTATA=100; ignorata listruzione o il blocco di istruzioni
var (tra begin ed end) dopo il then e viene eseguita
soldi, puntata, dado: integer; la parte else.
risposta: char; Qui il blocco di istruzioni nel primo begin end
(* parte esecutiva *) viene ignorato solo se il giocatore perde quindi
begin quel blocco viene ignorato per passare allaltro
clrscr; blocco begin end dopo else che soddisfa la
soldi :=0; puntata :=0; dado:=0; risposta:= ; condizione nel caso il giocatore perdesse.
writeln(Con quanti soldi vuoi partire); Poich nel primo e nel secondo blocco di
readln(soldi); begin..end ce la stessa istruzione possiedi ora
soldi si pu eliminare dai due blocchi e
repeat mettere fuori dal ciclo dopo end;
writeln(Quanto punti ?);
readln (puntata ); Quindi alla fine quando siamo in presenza di un
dado:= random(6) + 1; costrutto ifthen..else quando siamo in
writeln(E uscito: ,dado); presenza di una singola istruzione o blocco di
if dado>=4 then istruzione che sia uguale nel blocco beginend
begin e nel blocco elsebeginend si pu togliere e
soldi := soldi + puntata; mettere fuori dal costrutto.
writeln(Complimenti !! Hai vinto !!! ); Possiamo ancora migliorare il programma
writeln(Possiedi ora , soldi, euro.) chiedendogli di non scendere con il budget
end sotto lo zero. A questo punto la struttura
else cambia come descritto nella tabella sotto.
begin
soldi:= soldi puntata;
writeln(Hai perso !! Riprova !!);
writeln(Possiedi ora , soldi, euro.)
end;
writeln(Possiedi ora , soldi, euro.);

writeln(Vuoi giocare ancora ? (S/N) );

readln( risposta );
until upcase (risposta) =N;
writeln(Hai terminato con questi soldi: ,soldi);
writeln(Premi invio per continuare);
readln;
end.
 (* intestazione programma *) Ho aggiunto un ciclo repeat dove ho detto al
program dadi programma che non si pu puntare pi di quello
(* parte dichiarativa *) che si possiede. Da notare che il repeat aggiunto
uses crt; sta dentro il repeat esterno che regge il gioco.
const Non solo ma cambiamo la condizione di
MAX_PUNTATA=100; terminazione chiedendo che unaltra condizione
var che ci consente di uscire dal programma quando
soldi, puntata, dado: integer; i soldi sono azzerati pertanto luntil cambia.
risposta: char; A questo punto non ha pi senso chiedere al
(* parte esecutiva *) programma se si vuole continuare a giocare non
begin avendo soldi il giocatore.
clrscr;
soldi :=0; puntata :=0; dado:=0; risposta:= ;
writeln(Con quanti soldi vuoi partire); if soldi>0 then
readln(soldi); begin
repeat writeln(Vuoi giocare ancora ? (S/N) );
repeat readln( risposta );
writeln(Quanto punti ? (max , soldi , euro) end
); else
readln (puntata ); writeln(Hai perso tutto il tuo gioco termina !!);
if puntata>soldi then until (upcase (risposta) =N) or (soldi=0);
writeln(Attenzione stai puntando pi di writeln(Hai terminato con questi soldi: ,soldi);
quello che hai !!); writeln(Premi invio per continuare);
until puntata<=soldi; readln;
dado:= random(6) + 1; end.
writeln(E uscito: ,dado);
if dado>=4 then
begin
soldi := soldi + puntata;
writeln(Complimenti !! Hai vinto !!! );
end
else
begin
soldi:= soldi puntata;
writeln(Hai perso !! Riprova !!);
end;
writeln(Possiedi ora , soldi, euro.);

Vediamo ora degli esempi con delle condizioni strutturate ovvero composte con i
connettivi logici and, or, not;
22.20 riprendi lezione