Corso di Laurea in Biotecnologie
Informatica
(Programmazione)
Controllo del flusso di esecuzione:
selezione e iterazione
Anno Accademico 2009/2010
1
Controllo del flusso
Nella programmazione procedurale (o imperativa)
esistono dei costrutti sintattici (o strutture sintattiche)
per controllare il flusso di esecuzione di un programma.
In altre parole, tali costrutti servono per specificare
come (se, quando, quante volte, etc.) devono essere
eseguite le istruzioni che compongono un dato
programma.
Nelle prossime slide verranno trattati i costrutti per
specificare un i seguenti tipi di controllo del flusso:
 sequenziale
 di selezione
 di iterazione
2
Controllo sequenziale
Il controllo del flusso è di tipo sequenziale quando un
blocco di istruzioni viene eseguito seguendo l’ordine in
cui le istruzioni sono state scritte dal programmatore.
Non ci sono particolari costrutti sintattici che lo
realizzano perché è il controllo di default di
esecuzione del programma.
Ad esempio:
int x=1;
Questo frammento di codice
implica un controllo di tipo
sequenziale: le istruzioni
vengono eseguite nello stesso
ordine in cui sono state scritte
x=x+1;
System.out.println(x)
3
Controllo di selezione
Il controllo del flusso è di selezione quando un blocco
di istruzioni viene eseguito solo se si verifica una
determinata condizione.
I costrutti (che vedremo) che permettono di
realizzare un controllo di selezione sono:
 costrutto if, o di selezione a una via
 costrutto if-else, o di selezione a due vie
4
Costrutto if (selezione a una via)
Il costrutto if permette di specificare:
 un blocco di istruzioni  B
 una condizione da verificare  C
Come funziona: le istruzioni del blocco B
vengono eseguite solo se si verifica la
condizione C. Se la condizione C non è verificata
allora B viene saltato
5
Costrutto if (selezione a una via)
La sintassi Java del costrutto a una via if è la seguente:
if(<bool_expr>){
<block>
}
dove <bool_expr> è l’espressione booleana che
rappresenta la condizione da verificare C e <block> è il
blocco di istruzioni che vengono eseguite se C è verificata,
ovvero se la valutazione di <bool_expr> restituisce true.
Se la valutazione di <bool_expr> restituisce false, allora
le istruzioni in <block> vengono saltate e si continua ad
eseguire la parte di programma eventualmente scritto dopo
il costrutto if.
6
Costrutto if (selezione a una via)
Esempio:
int x=3;
if(x > 2){
x=x+1;
}
System.out.println(x);
La stampa è 4
7
Costrutto if (selezione a una via)
Esempio:
int x=3;
if(x < 3){
x=x+1;
}
System.out.println(x);
La stampa è 3
8
Costrutto if-else (selezione a due vie)
Il costrutto if-else permette di specificare:
 un primo blocco di istruzioni  B1
 un secondo blocco di istruzioni  B2
 una condizione da verificare  C
Come funziona: le istruzioni del blocco B1
vengono eseguite solo se si verifica la
condizione C. Se la condizione C non è verificata
allora B1 viene saltato e vengono eseguite le
istruzioni in B2 (alternativa a B1)
9
Costrutto if-else (selezione a due vie)
La sintassi Java del costrutto a due vie if-else è la seguente:
if(<bool_expr>){
<block1>
}
else{
<block2>
}
dove <bool_expr> è l’espressione booleana che rappresenta la
condizione da verificare C e <block1> è il blocco di istruzioni
che vengono eseguite se C è verificata, ovvero se la valutazione
di <bool_expr> restituisce true.
Se la valutazione di <bool_expr> restituisce false, allora le
istruzioni in <block1> vengono saltate vengono eseguite le
istruzioni specificate in <block2>.
10
Costrutto if-else (selezione a due vie)
Esempio:
int x=3, y=4, min;
if(x < y){
min=x;
}
else{
min=y;
}
System.out.println(min);
La stampa è 3
11
Costrutti di selezione annidati
I blocchi di istruzioni di un costrutto di selezione (a una
o a due vie) possono essere a loro volta costrutti di
selezione (a una o a due vie). Ad esempio:
if(<bool_expr1>){
if(<bool_expr2>){
<block1>
}
else{
<block2>
}
}
else{
if(<bool_expr3>){
<block3>
}
else{
<block4>
}
}
blocco di codice relativo al costrutto
if-else più esterno, che viene
eseguito se <bool_expr1> restituisce
true
blocco di codice relativo al costrutto
if-else più esterno, che viene
eseguito se <bool_expr1> restituisce
false
12
Costrutti di selezione annidati
Esempio:
int x=3, y=4, z;
if(x != y){
if(x < y){
z=x;
}
else{
z=y;
}
}
else{
z=0;
}
System.out.println(z);
La stampa è 3
13
Controllo di iterazione
Il controllo del flusso è di iterazione quando un
blocco di istruzioni viene eseguito ripetutamente
finché si verifica una determinata condizione.
I costrutti (che vedremo) che permettono di
realizzare un controllo di iterazione sono:
 costrutto while
 costrutto do-while
Sono chiamati anche CICLI
 costrutto for
14
Ciclo while (iterazione)
Il costrutto while permette di specificare:
 un blocco di istruzioni  B
 una condizione da verificare  C
Come funziona: le istruzioni del blocco B
vengono eseguite ripetutamente finché si
verifica la condizione C.
15
Ciclo while (iterazione)
La sintassi Java del costrutto while è la seguente:
while(<bool_expr>){
<block>
}
dove <bool_expr> è l’espressione booleana che
rappresenta la condizione da verificare C e <block> è il
blocco di istruzioni che vengono eseguite ripetutamente
finché C è verificata, ovvero finché la valutazione di
<bool_expr> restituisce true.
Quando la valutazione di <bool_expr> restituisce false,
le istruzioni in <block> vengono saltate e si continua ad
eseguire la parte di programma eventualmente scritto dopo
il costrutto while.
16
Ciclo while (iterazione)
In altre parole, quando l’esecuzione del programma
incontra un ciclo while, per prima cosa viene valutata
l’espressione booleana <bool_expr>. Se questa
restituisce false, allora <block> viene subito saltato e
si passa ad eseguire l’eventuale parte di programma
scritto dopo il ciclo while. Se invece restituisce true il
blocco di istruzioni <block> viene eseguito e, subito
dopo, viene rivalutata <bool_expr>. Se questa di nuovo
restituisce true, <block> viene eseguito nuovamente, e
così di seguito finchè la valutazione di <bool_expr> non
resituisce false. A questo punto <block> viene saltato e
si passa ad eseguire l’eventuale parte di programma
scritto dopo il ciclo while.
17
Ciclo while (iterazione)
Quindi:
 <bool_expr> governa le iterazioni e la
terminazione del ciclo
 all’interno di <block> ci deve essere un “qualcosa”
che, ad un certo punto, renda false il risultato di
<bool_expr> e che interrompa quindi le iterazioni
 è possibile che <block> non venga eseguito
nemmeno una volta (cioè, quando la prima valutazione
di <bool_expr> restituisce false)
18
Ciclo while (iterazione)
Esempio:
int x=1;
while(x <= 10){
System.out.println(x);
x=x+1;
}
x=x+1 è in questo caso l’istruzione che
permette ad un certo punto di uscire dal
ciclo while. Se non esistesse, il numero delle
iterazioni sarebbe infinito perché la
condizione (x<=10) sarebbe sempre verificata
Questo frammento di codice stampa gli interi da 1 a 10.
19
Ciclo while (iterazione)
Esempio:
int x=10;
while(x > 0){
System.out.println(x);
x=x-1;
}
x=x-1 è in questo caso l’istruzione che
permette ad un certo punto di uscire dal
ciclo while. Se non esistesse, il numero delle
iterazioni sarebbe infinito perché la
condizione (x > 0) sarebbe sempre verificata
Questo frammento di codice stampa gli interi da 10 a 1.
20
Ciclo while (iterazione)
Esempio:
int num=1;
int s=0;
while(num <= 5){
Questo codice stampa la
somma degli interi da 1 a 5
 1+2+3+4+5  15
s=s+num;
num++;
}
System.out.println(s);
La stampa è 15
21
Ciclo while (iterazione)
Esempio:
int num=6;
int s=0;
while(num <= 5){
s=s+num;
num++;
}
L’espressione num <= 5
all’inizio restituisce false
in quanto num è
inizializzata a 6. In tale
caso il blocco di codice del
ciclo while non viene
mai eseguito e quindi il
contenuto della variabile
s rimane a 0
(che è il suo valore di
inizializzazione)
System.out.println(s);
La stampa è 0
22
Ciclo do-while (iterazione)
Il costrutto do-while permette di specificare:
 un blocco di istruzioni  B
 una condizione da verificare  C
Come funziona: le istruzioni del blocco B
vengono eseguite ripetutamente finché si
verifica la condizione C, ma all’inizio il blocco B
viene eseguito comunque eseguito.
23
Ciclo do-while (iterazione)
La sintassi Java del costrutto do-while è la seguente:
do{
<block>
}while(<bool_expr>);
dove <bool_expr> è l’espressione booleana che
rappresenta la condizione da verificare C e <block> è il
blocco di istruzioni che vengono eseguite ripetutamente (e
comunque all’inzio) finché C è verificata, ovvero finché la
valutazione di <bool_expr> restituisce true.
Quando la valutazione di <bool_expr> restituisce false,
le istruzioni in <block> vengono saltate e si continua ad
eseguire la parte di programma eventualmente scritto dopo
il costrutto while.
24
Ciclo do-while (iterazione)
In altre parole, quando l’esecuzione del programma
incontra un ciclo do-while, per prima cosa viene eseguito il
blocco di istruzioni <block>. Subito dopo viene valutata
l’espressione booleana <bool_expr>. Se questa
restituisce false, allora le iterazioni terminano e si passa
ad eseguire l’eventuale parte di programma scritto dopo il
ciclo do-while. Se invece restituisce true il blocco di
istruzioni <block> viene eseguito nuovamente, e così di
seguito finchè la valutazione di <bool_expr> non
resituisce false. A questo punto si esce dal ciclo si passa
ad eseguire l’eventuale parte di programma scritto dopo il
ciclo while.
25
Ciclo do-while (iterazione)
Quindi:
 <bool_expr> governa le iterazioni e la
terminazione del ciclo
 all’interno di <block> ci deve essere un “qualcosa”
che, ad un certo punto, renda false il risultato di
<bool_expr> e che interrompa quindi le iterazioni
 <block> viene eseguito almeno una volta (a
differenza del ciclo while), in quanto la valutazione
dell’espressione booleana avviene dopo aver eseguito
il blocco (e non prima come nel ciclo while)
26
Ciclo do-while (iterazione)
Esempio:
int num=1;
int s=0;
do{
Questo codice stampa la
somma degli interi da 1 a 5
 1+2+3+4+5  15
s=s+num;
num++;
}while(num <= 5);
System.out.println(s);
La stampa è 15
27
Ciclo do-while (iterazione)
Esempio:
int num=6;
int s=0;
do{
L’istruzione s=s+num
una volta viene comunque
eseguita e quindi il contenuto
della variabile s al
della stampa è 6.
s=s+num;
num++;
}while(num <= 5);
System.out.println(s);
La stampa è 6
28
Ciclo for (iterazione)
Il costrutto for permette di specificare:
 un blocco di istruzioni  B
 una condizione da verificare  C
 un’istruzione di inizializzazione  I
 un’istruzione di aggiornamento  U
Come funziona: le istruzioni del blocco B vengono
eseguite ripetutamente finché si verifica la condizione
C. L’istruzione I viene eseguita una sola volta all’inizio
del ciclo e l’istruzione U viene eseguita ad ogni
iterazione subito dopo avere eseguito il blocco B.
29
Ciclo for (iterazione)
La sintassi Java del costrutto for è la seguente:
for(<init_instr>; <bool_expr>; <upd_instr>){
<block>
}
dove <bool_expr> è l’espressione booleana che rappresenta la
condizione da verificare C e <block> è il blocco di istruzioni che
vengono eseguite ripetutamente finché C è verificata, ovvero
finché la valutazione di <bool_expr> restituisce true.
<upd_instr> rappresenta l’istruzione di aggiornamento U che
viene eseguita alla fine di ogni esecuzione di <block> e
<init_instr> rappresenta l’istruzione di inizializzazione I che
viene eseguita una sola volta all’inizio del ciclo. Quando la
valutazione di <bool_expr> restituisce false, le istruzioni in
<block> vengono saltate e si continua ad eseguire la parte di
programma eventualmente scritto dopo il costrutto for.
30
Ciclo for (iterazione)
In altre parole, quando l’esecuzione del programma incontra
un ciclo for, per prima cosa viene eseguita l’istruzione
<init_instr>, poi viene valutata l’espressione booleana
<bool_expr>. Se questa restituisce false, allora <block>
viene subito saltato e si passa ad eseguire l’eventuale parte
di programma scritto dopo il ciclo for. Se invece restituisce
true il blocco di istruzioni <block> viene eseguito e, subito
dopo, viene eseguita l’istruzione di aggiornamento
<upd_instr>. Viene poi rivalutata <bool_expr>. Se questa
di nuovo restituisce true, <block> viene eseguito
nuovamente (e subito dopo <upd_instr>), e così di seguito
finchè la valutazione di <bool_expr> non resituisce false.
A questo punto <block> viene saltato e si passa ad eseguire
l’eventuale parte di programma scritto dopo il ciclo for.
31
Ciclo for (iterazione)
Quindi:
 <bool_expr> governa le iterazioni e la
terminazione del ciclo
 l’istruzione <upd_instr> è quel “qualcosa” che, ad
un certo punto, rende false il risultato di
<bool_expr> e che interrompe quindi le iterazioni
 <init_instr> viene eseguita solo una volta
 è possibile che <block> non venga eseguito
nemmeno una volta (cioè, quando la prima valutazione
di <bool_expr> restituisce false)
32
Ciclo for (iterazione)
Esempio:
int x;
for(x=1; x <= 10; x=x+1){
System.out.println(x);
}
x=1 è l’istruzione
di inizializzazione
x=x+1 è in questo caso
l’istruzione di aggiornamento
che permette ad un certo
punto di uscire dal ciclo for
Questo frammento di codice stampa gli interi da 1 a 10.
33
Ciclo for (iterazione)
Esempio:
int x;
for(x=10; x > 10; x=x-1){
System.out.println(x);
}
x=10 è l’istruzione
di inizializzazione
x=x-1 è in questo caso
l’istruzione di aggiornamento
che permette ad un certo
punto di uscire dal ciclo for
Questo frammento di codice stampa gli interi da 10 a 1.
34
Ciclo for (iterazione)
Esempio:
int num;
int s;
Questo codice stampa la
somma degli interi da 1 a 5
 1+2+3+4+5  15
for(num=1; num <= 5; num=num+1){
s=s+num;
}
System.out.println(s);
La stampa è 15
35