Corso di Laurea in Biotecnologie Informatica (Programmazione) Controllo del flusso di esecuzione: selezione e iterazione Anno Accademico 2009/2010

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

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; x=x+1; System.out.println(x) Questo frammento di codice implica un controllo di tipo sequenziale: le istruzioni vengono eseguite nello stesso ordine in cui sono state scritte

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

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

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.

Costrutto if (selezione a una via) Esempio: int x=3; if(x > 2){ x=x+1; } System.out.println(x); La stampa è 4

Costrutto if (selezione a una via) Esempio: int x=3; if(x < 3){ x=x+1; } System.out.println(x); La stampa è 3

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)

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>.

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

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> if(<bool_expr3>){ <block3> <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

Costrutti di selezione annidati Esempio: int x=3, y=4, z; if(x != y){ if(x < y){ z=x; } else{ z=y; z=0; System.out.println(z); La stampa è 3

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 costrutto for Sono chiamati anche CICLI

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.

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.

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.

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)

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.

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.

Ciclo while (iterazione) Esempio: int num=1; int s=0; while(num <= 5){ s=s+num; num++; } System.out.println(s); Questo codice stampa la somma degli interi da 1 a 5  1+2+3+4+5  15 La stampa è 15

Ciclo while (iterazione) Esempio: int num=6; int s=0; while(num <= 5){ s=s+num; num++; } System.out.println(s); 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) La stampa è 0

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.

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.

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.

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)

Ciclo do-while (iterazione) Esempio: int num=1; int s=0; do{ s=s+num; num++; }while(num <= 5); System.out.println(s); Questo codice stampa la somma degli interi da 1 a 5  1+2+3+4+5  15 La stampa è 15

Ciclo do-while (iterazione) Esempio: int num=6; int s=0; do{ s=s+num; num++; }while(num <= 5); System.out.println(s); L’istruzione s=s+num una volta viene comunque eseguita e quindi il contenuto della variabile s al della stampa è 6. La stampa è 6

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.

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.

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.

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)

Ciclo for (iterazione) Esempio: int x; for(x=1; x <= 10; x=x+1){ System.out.println(x); } x=x+1 è in questo caso l’istruzione di aggiornamento che permette ad un certo punto di uscire dal ciclo for x=1 è l’istruzione di inizializzazione Questo frammento di codice stampa gli interi da 1 a 10.

Ciclo for (iterazione) Esempio: int x; for(x=10; x > 10; x=x-1){ System.out.println(x); } x=x-1 è in questo caso l’istruzione di aggiornamento che permette ad un certo punto di uscire dal ciclo for x=10 è l’istruzione di inizializzazione Questo frammento di codice stampa gli interi da 10 a 1.

Ciclo for (iterazione) Esempio: int num; int s; for(num=1; num <= 5; num=num+1){ s=s+num; } System.out.println(s); Questo codice stampa la somma degli interi da 1 a 5  1+2+3+4+5  15 La stampa è 15