Introduzione al C. Unità 4 Istruzioni di Ciclo

Transcript

1 Corso di Fondamenti di Informatica Ingegneria delle Comunicazioni BCOR Ingegneria Elettronica BELR Introduzione al C Unità 4 Istruzioni di Ciclo D. Bloisi, S. Peluso, S. Salza

2 Sommario Unità 4 Ripetizione di istruzioni Istruzione while Ciclo di lettura Schemi di ciclo Istruzione for Istruzione do Cicli annidati Istruzioni di controllo del flusso Istruzioni di Ciclo - Unità /2013 Pagina 2

3 Istruzioni di controllo del flusso Finora abbiamo visto diversi tipi di istruzioni (senza contare le dichiarazioni): istruzioni semplici: invocazione di funzioni istruzioni semplici, ovvero assegnazione o uso di un operatore di incremento/decremento seguito da ";" istruzioni di uscita (break e return) istruzioni composte (o strutturate) blocco di istruzioni ({) istruzioni condizionali (if-else, if, switch) Pagina 3

4 Ripetizione di istruzioni Nei linguaggi di programmazione esistono due modi per ottenere la ripetizione di istruzioni: l'utilizzo di istruzioni di ciclo (o iterative), che sono una forma di istruzione composta l'utilizzo di funzioni ricorsive Pagina 4

5 Cicli definiti ed indefiniti Si distinguono due tipi di ciclo, che si differenziano in base a come viene determinato il numero di iterazioni (ripetizioni del corpo del ciclo): Nei cicli definiti il numero di iterazioni è noto prima di iniziare l'esecuzione del ciclo. Nei cicli indefiniti il numero di iterazioni non è noto prima di iniziare l'esecuzione del ciclo, ma è legato al verificarsi di una condizione (questo dipende a sua volta dalle operazioni eseguite nel corpo del ciclo). Pagina 5

6 Esempi Ciclo definito: Per 10 volte ripeti la stampa di un *. Numero di iterazioni noto a tempo di compilazione. Ciclo indefinito: Finché l utente non sceglie di smettere, stampa un * e chiedi all utente se smettere. Numero di iterazioni noto a tempo di esecuzione. In C, entrambi i tipi di ciclo possono essere realizzati attraverso l istruzione while. Pagina 6

7 Ciclo while L istruzione while consente la ripetizione di una istruzione. Sintassi while (condizione) istruzione condizione è un espressione istruzione (detta anche il corpo del ciclo) è una singola istruzione (anche composta come un blocco di istruzioni) Pagina 7

8 Semantica 1. La condizione è valutata. 2. Se la condizione è vera, allora l istruzione è eseguita e successivamente si ritorna sulla valutazione della condizione, procedendo così fino a quando la condizione risulta falsa. 3. Si esegue poi l istruzione successiva al ciclo while. Il corpo del ciclo viene eseguito finché la condizione si mantiene vera. Non appena questa diventa falsa, si esce dal ciclo e si continua l esecuzione con l istruzione successiva al while. Pagina 8

9 Esempio stampa di 100 asterischi (ciclo definito) int i = 0; while (i < 100) { printf("*"); i++; Pagina 9

10 Controllo del flusso while(condizione){ istruzione-1 istruzione-n istruzione-n+1 0 vero istruzione-1 istruzione-n condizione 0 falso istruzione-n+1 Pagina 10

11 Ciclo while per la lettura lettura e stampa su video di un insieme di caratteri in input. #include <stdio.h> int main () { int c; c = getchar(); while (c!= EOF) { putchar(c); c = getchar(); return 0; ciclo Indefinito Le iterazioni continuano fino a quando non vengono premuti contemporaneamente i tasti CTRL e Z (Windows) oppure CTRL e D (Unix) Pagina 11

12 Funzione getchar Legge il prossimo carattere dallo standard input e lo restituisce come valore intero int getchar( void ); Il carattere letto è restituito come int. Se si raggiunge End Of File o viene riscontrato un errore in lettura, la funzione ritorna il valore della costante simbolica di tipo int EOF (che generalmente vale -1) definita in stdio.h. Pagina 12

13 Funzione putchar Visualizza sullo standard output il carattere immagazzinato in c int putchar( int c ); Se non ci sono errori, lo stesso carattere letto viene restituito. Se si verifica un errore, viene restituito EOF. Pagina 13

14 Ciclo while per la lettura Versione alternativa Lettura e stampa su video di un insieme di caratteri in input. #include <stdio.h> int main () { int c; while ((c = getchar())!= EOF) putchar(c); return 0; ciclo indefinito Pagina 14

15 Esempio di esecuzione Pagina 15

16 Esempio stampa del doppio degli interi letti in input. #include <stdio.h> int main () { int c, dato; c = scanf("%d", &dato); while (c!= EOF) { dato *= 2; printf("%d\n", dato); c = scanf("%d", &dato); return 0; ciclo indefinito Pagina 16

17 Struttura generale del ciclo di lettura lettura del primo elemento; while (elemento è valido) { elaborazione elemento; lettura elemento successivo; Pagina 17

18 Esempio di ciclo while: divisione con le sottrazioni int dividendo, divisore, quoziente, resto; dividendo =...; divisore =...; quoziente = 0; resto = dividendo; ciclo while (resto >= divisore) { definito quoziente++; resto -= divisore; printf("quoziente = %d\n", quoziente); printf("resto = %d\n", resto); Pagina 18

19 Esempio di ciclo while: potenza int base, esponente, potenza; base =...; esponente =...; potenza = 1; while (esponente > 0) { potenza *= base; esponente--; ciclo definito Pagina 19

20 Esempio di ciclo while: prodotto con le somme int moltiplicando, moltiplicatore, prodotto; moltiplicando =...; moltiplicatore =...; prodotto = 0; while (moltiplicatore > 0) { prodotto += moltiplicando; moltiplicatore--; ciclo definito Pagina 20

21 Elementi caratteristici nella progettazione di un ciclo Definizione del valore delle variabili utilizzate nel ciclo prima dell inizio dell esecuzione del ciclo inizialiazzazione while (condizione) { operazione passo successivo Espressione valutata all inizio di ogni iterazione, il cui valore di verità determina l esecuzione del corpo del ciclo o la fine del ciclo Calcolo del risultato parziale ad ogni iterazione del ciclo (nel corpo del ciclo) Operazione di incremento/decremento della variabile che controlla le ripetizioni del ciclo (nel corpo del ciclo) Pagina 21

22 Terminazione Una volta progettato il ciclo occorre verificarne la terminazione. Occorre, cioè, verificare che l esecuzione delle istruzioni del ciclo possa modificare il valore della condizione in modo da renderla falsa. Esempio: L'istruzione moltiplicatore--; consente di rendere la condizione (moltiplicatore > 0) falsa, se moltiplicatore è un numero intero positivo. Pagina 22

23 Errori comuni nella scrittura di cicli while (1/3) Mancata inizializzazione di una variabile che viene utilizzata nella condizione del ciclo. int i; while (i!= 0) { printf("%d\n", i); printf("%d\n", i*i); printf("prossimo intero\n"); Pagina 23

24 Errori comuni nella scrittura di cicli while (2/3) Mancato aggiornamento delle variabili che compaiono nella condizione del ciclo. int i, dato; printf("inserisci intero:\n"); i = scanf("%d", &dato); while (i!= EOF) { printf("quadrato di %d = %d\n", dato, dato*dato); Pagina 24

25 Errori comuni nella scrittura di cicli while (3/3) Numero di iterazioni errato di 1 Esempio: stampa di 10 asterischi int i = 0; while (i <= 10) { printf("*"); i++; // corretto: (i < 10) Pagina 25

26 Schemi di ciclo contatore: conta il numero di valori in un insieme accumulatore: accumula i valori di un insieme valori caratteristici di un insieme: determina un valore caratteristico tra i valori in un insieme (ad esempio, il massimo, quando sui valori dell'insieme e definito un ordinamento) Pagina 26

27 Schema di ciclo contatore: numero di interi immessi in input int d, i; int contatore = 0; printf("inserisci intero:\n"); i = scanf("%d", &d); while (i!= EOF) { contatore++; printf("ho letto: %d\n", d); printf("inserisci intero:\n"); i = scanf("%d", &d); printf("\nfine lettura, ho letto %d " " interi\n", contatore); Pagina 27

28 Schema di ciclo contatore: numero di interi positivi immessi in input int d, i; int contatore = 0; printf("inserisci intero:\n"); i = scanf("%d", &d); while (i!= EOF) { if(d > 0) contatore++; printf("ho letto: %d\n", d); printf("inserisci intero:\n"); i = scanf("%d", &d); printf("\nfine lettura, ho letto %d " " interi positivi\n", contatore); Pagina 28

29 Schema di ciclo accumulatore: somma valori interi int d; //intero corrente int i; int somma; //variabile usata come accumulatore somma = 0; printf("inserisci intero:\n"); i = scanf("%d", &d); while (i!= EOF) { somma += d; printf("inserisci intero:\n"); i = scanf("%d", &d); printf("\nsomma totale = %d\n", somma); Pagina 29

30 Schema di ciclo accumulatore: prodotto valori interi int n; //intero corrente int i; int prodotto; //variabile usata come accumulatore prodotto = 1; printf("inserisci intero:\n"); i = scanf("%d", &n); while (i!= EOF) { prodotto *= n; printf("inserisci intero:\n"); i = scanf("%d", &n); printf("\nprodotto totale = %d\n", prodotto); Pagina 30

31 Schema di ciclo valori caratteristici di un insieme: massimo di un intervallo noto Problema trovare il massimo di un insieme di numeri interi dati in input. int max; // massimo corrente max = 0; int d, i; printf("inserisci intero:\n"); i = scanf("%d", &d); while (i!= EOF) { if (d > max) max = d; printf("inserisci intero:\n"); i = scanf("%d", &d); printf("\n"); if (max == 0) printf("insieme di valori vuoto\n"); else printf("massimo intero letto = %d\n", max); Assunzioni intervallo di interi noto, è possibile denotare valori estremi (es. tutti i valori sono > 0) l insieme di interi può essere vuoto Pagina 31

32 Schema di ciclo valori caratteristici di un insieme: massimo di un insieme non vuoto double f; // reale corrente double max; // massimo corrente int i; printf("inserisci dato:\n"); i = scanf("%lf", &f); max = f; while (i!= EOF) { if (f > max) max = f; printf("inserisci dato:\n"); i = scanf("%lf", &f); printf("\nmassimo = %f\n", max); Problema trovare il massimo di un insieme di numeri reali dati in input. Assunzioni nell insieme vi è almeno un reale l intervallo di reali non è noto, non si possono denotare i valori estremi. Pagina 32

33 Schema di ciclo valori caratteristici di un insieme: massimo nel caso generale double f; // reale corrente double max = 0; // massimo corrente int i; printf("inserisci dato:\n"); i = scanf("%lf", &f); if(i == EOF) printf("\ninsieme di valori vuoto\n"); else { max = f; while (i!= EOF) { if (f > max) max = f; printf("inserisci dato:\n"); i = scanf("%lf", &f); printf("\nmassimo = %f\n", max); Problema trovare il massimo di un insieme di numeri reali dati in input. Assunzioni l insieme di reali potrebbe essere vuoto l intervallo di reali non è noto Pagina 33

34 Istruzioni di ciclo Il C mette a disposizione tre forme di istruzioni di ciclo: ciclo while ciclo for ciclo do-while Il ciclo while è sufficiente per esprimere qualsiasi ciclo esprimibile con for e do. In alcune situazioni è più conveniente codificare un algoritmo utilizzando gli altri tipi di ciclo. Pagina 34

35 Ciclo controllato da contatore (while) Una situazione comune di utilizzo dei cicli è quella in cui il ciclo fa uso di una variabile (detta di controllo) che ad ogni iterazione varia di un valore costante, ed il cui valore determina la fine del ciclo. variabile di controllo i inizializzazione incremento / decremento verifica int i = 1; while (i <= 10) { printf("%d\n", i * i); i++; Pagina 35

36 Ciclo controllato da contatore (for) L istruzione di ciclo for è adatta ad esprimere le situazioni in cui si utilizzano variabili di controllo. variabile di controllo i inizializzazione verifica incremento / decremento int i; for (i = 1; i <= 10; i++ ) printf("%d\n", i * i); Pagina 36

37 Istruzione for Sintassi for (inizializzazione ; condizione ; incremento ) istruzione inizializzazione è un espressione con side-effect di inizializzazione di una variabile di controllo (tipicamente un assegnazione). condizione è un espressione condizionale. incremento è un espressione con side-effect che tipicamente consiste nell incremento della variabile di controllo. istruzione è una singola istruzione (detta anche il corpo del ciclo for ). Pagina 37

38 Semantica for (inizializzazione ; condizione ; incremento ) istruzione è equivalente a inizializzazione ; while (condizione) { istruzione incremento ; Nota: C è un eccezione che riguarda l istruzione continue, che viene tradotta in modo più complicato. Pagina 38

39 Controllo del flusso for (inizializzazione ; condizione ; incremento ) { istruzione-1 istruzione-n istruzione-n+1 0 vero inizializzazione condizione istruzione-1 istruzione-n incremento 0 falso istruzione-n+1 Pagina 39

40 Osservazioni sul ciclo for (1/3) Ciascuna delle tre parti del for (inizializzazione, condizione e incremento ) può mancare. In ogni caso i ";" vanno comunque inseriti. Se manca condizione, viene assunta pari al valore 1 (vero). Esempio: for(;;) Pagina 40

41 Osservazioni sul ciclo for (2/3) La sintassi del for permette che le tre parti siano delle espressioni qualsiasi, purché inizializzazione ; e incremento ; siano delle istruzioni (in particolare, facciano side-effect). Nell uso del ciclo for è però buona norma: usare le tre parti del for in base al significato descritto, con riferimento ad una variabile di controllo; non modificare la variabile di controllo nel corpo del ciclo. Pagina 41

42 Osservazioni sul ciclo for (3/3) In generale, inizializzazione e/o incremento possono essere una sequenza di espressioni con side-effect separate da ",". Questo permette di inizializzare e/o incrementare più variabili contemporaneamente. int i, potdi2; for (i=0, potdi2=1; i < 10; i++, potdi2 *= 2) printf("2^%d = %d\n", i, potdi2); Pagina 42

43 Cicli for: esempi Il ciclo for è usato principalmente per realizzare cicli definiti. int i; for (i = 1; i <= 10; i++)... valori assunti da i: 1, 2, 3,..., 10 for (i = 10; i >= 1; i--)... valori assunti da i: 10, 9, 8,..., 2, 1 for (i = -4; i <= 4; i = i+2)... valori assunti da i: -4, -2, 0, 2, 4 for (i = 0; i >= -10; i = i-3)... valori assunti da i: 0, -3, -6, -9 Pagina 43

44 Esempio: codice caratteri int i; for (i = 33; i <= 62; i++) { char c = (char)i; printf("i = %d -> c = %c\n", i, c); Stampa dei caratteri ASCII compresi tra 33 e 62. Pagina 44

45 Esempio: esecuzione Pagina 45

46 Istruzione do-while Sintassi do istruzione while (condizione); condizione è un espressione che restituisce un valore vero ( 0) o falso (0) istruzione è una singola istruzione (detta anche il corpo del ciclo) Pagina 46

47 Semantica do istruzione while (condizione); è equivalente a istruzione ; while (condizione) istruzione Quindi: viene prima eseguita istruzione poi viene valutata condizione, se è vera, si torna ad eseguire istruzione, procedendo così fino a quando condizione diventa falsa a questo punto, si passa ad eseguire l istruzione che segue il ciclo do Pagina 47

48 Esempio int i = 0; do { printf("*"); i++; while (i < 100); Stampa di 100 asterischi Pagina 48

49 Osservazioni sul ciclo do-while Il corpo del ciclo viene eseguito almeno una volta. Non è, in generale, necessario inizializzare le variabili che compaiono nella condizione prima di iniziare l'esecuzione del ciclo. E sufficiente che tali variabili vengano inizializzate nel corpo del ciclo stesso. Pagina 49

50 Esempio somma gli interi letti da input fino a quando non viene immesso 0. #include <stdio.h> int main() { int i; int somma = 0; do { printf("inserisci intero (0 per terminare):\n"); scanf("%d", &i); somma = somma + i; while (i!= 0); printf("\ntotale = %d\n", somma); return 0; Pagina 50

51 Domanda Cosa stampa il frammento di codice seguente? int i; do { i = 0; printf("*"); i++; while (i < 100); Pagina 51

52 Buona norma La sintassi del ciclo do richiede che ci sia un ";" dopo while (condizione). Per aumentare la leggibilità del programma, in particolare per evitare di confondere la parte while(condizione); di un ciclo do, con un istruzione while con corpo vuoto, conviene in ogni caso racchiudere il corpo del ciclo do in un blocco, ed indentare il codice come segue: do { istruzione while (condizione); Pagina 52

53 Controllo del flusso do { istruzione-1 istruzione-n while (condizione); istruzione-n+1 istruzione-1 istruzione-n istruzione-n+1 0 falso condizione 0 vero Pagina 53

54 Validazione dell input Spesso è necessario effettuare una validazione (convalida, dall inglese validation) di un dato di input immesso dall utente. Nel caso in cui l utente abbia immesso un dato non valido, potrebbe essere necessario ripetere la richiesta del dato stesso. La validazione può essere realizzata intuitivamente utilizzando un ciclo do-while. Pagina 54

55 Esempio Scrivere un frammento di programma che legga da input un intero, ripetendo la lettura fino a quando non venga immesso un intero positivo, e restituisca l intero positivo letto.... int i; do { printf("inserisci un intero positivo:\n"); scanf("%d", &i); while (i <= 0); // all uscita dal ciclo i e un intero positivo... Pagina 55

56 Esecuzione Pagina 56

57 Equivalenza tra ciclo while e ciclo do-while do { printf("inserisci un intero positivo:\n"); scanf("%d", &i); while (i <= 0); equivale a printf("inserisci un intero positivo:\n"); scanf("%d", &i); while (i <= 0) { printf("inserisci un intero positivo:\n"); scanf("%d", &i); Pagina 57

58 Insieme completo di istruzioni di controllo Due programmi si dicono equivalenti se, sottoposti agli stessi dati di ingresso, entrambi non terminano, oppure entrambi terminano producendo gli stessi risultati in uscita. Un insieme di istruzioni di controllo del flusso si dice completo se per ogni programma nel linguaggio ne esiste uno equivalente scritto solo con le strutture di controllo contenute nell'insieme. Pagina 58

59 Teorema di Böhm e Jacopini La sequenza, l'istruzione if-else e l'istruzione while formano un insieme di istruzioni completo. Nota: La sequenza è la normale elencazione di istruzioni perché vengano eseguite una di seguito all'altra nell'ordine in cui sono state scritte dal programmatore. Pagina 59

60 Esempio: calcolo del massimo comune divisore (MCD) Specifica Si vuole realizzare un programma che, dati due interi positivi x ed y, calcoli e restituisca il massimo comun divisore mcd(x, y). Il massimo comun divisore di due interi x ed y è il più grande intero che divide sia x che y senza resto. Esempio mcd(12, 8) = 4 mcd(12, 6) = 6 mcd(12, 7) = 1 Pagina 60

61 MCD: sfruttando direttamente la definizione Cerchiamo il massimo tra i divisori comuni di x ed y Osservazione: 1 mcd(x, y) min(x, y) Quindi, si provano i numeri compresi tra 1 e min(x, y). Conviene iniziare da min(x, y) e scendere verso 1. Appena si è trovato un divisore comune di x ed y, lo si restituisce. Pagina 61

62 MCD: primo raffinamento dell algoritmo massimocomundivisore di int x ed int y { int mcd; inizializza mcd al minimo tra x ed y while ((mcd > 1) && (non si è trovato un divisore comune)) if (mcd divide sia x che y) si è trovato un divisore comune else mcd--; pseudocodice Pagina 62

63 Osservazioni Il ciclo termina sempre perché ad ogni iterazione o si è trovato un divisore, o si decrementa mcd di 1 (al più si arriva ad 1). Per verificare se si è trovato il mcd si utilizza una variabile intera che rappresenta un valore booleano (usata nella condizione del ciclo). Per verificare se x (o y) divide mcd si usa l operatore "%". Pagina 63

64 MCD: problemi legati alla prima versione dell algoritmo Quante volte viene eseguito il ciclo nel precedente algoritmo? caso migliore: 1 volta, quando x divide y o viceversa senza resto Es. mcd(500, 1000) caso peggiore: min(x,y) volte, quando mcd(x,y) = 1 Es. mcd(500, 1001) Quindi, il precedente algoritmo si comporta male se x e y sono grandi e mcd(x, y) è piccolo. Pagina 64

65 MCD usando il metodo di Euclide Il metodo di Euclide permette di ridurre velocemente il calcolo a numeri più piccoli, sfruttando la seguente proprietà: Esempio mcd(12, 8) = mcd(12 8, 8) = mcd(4, 8-4) = 4 Pagina 65

66 Dimostrazione del metodo di Euclide La validità di questo metodo si dimostra facilmente, mostrando che i divisori comuni di x e y sono anche divisori di x y (nel caso in cui x > y). Pagina 66

67 Codifica del metodo di Euclide per il calcolo del MCD #include <stdio.h> int main () { int x = 210; int y = 63; while (x!= y) { if (x > y) x = x - y; else // significa che y > x y = y - x; printf("mcd = %d\n", x); return 0; Pagina 67

68 MCD: ammissibilità dei valori degli argomenti Se x = y = 0? Il risultato è 0. Se x = 0 e y > 0 (o viceversa)? Il risultato dovrebbe essere y, ma l'algoritmo entra in un ciclo infinito. Se x < 0 e y è qualunque (o viceversa)? L'algoritmo entra in un ciclo infinito. Pagina 68

69 Codifica rivista del metodo di Euclide per il calcolo del MCD #include <stdio.h> int main () { int x = 210; int y = 63; if ((x > 0) && (y > 0)) { while (x!= y) if (x > y) x = x - y; else // significa che y > x y = y - x; printf("mcd = %d\n", x); else printf("dati errati\n"); return 0; Pagina 69

70 MCD usando il metodo di Euclide con i resti (1/2) Cosa succede nel precedente algoritmo se x è molto maggiore di y (o viceversa)? Pagina 70

71 MCD usando il metodo di Euclide con i resti (2/2) Per comprimere questa lunga sequenza di sottrazioni è sufficiente osservare che quello che in fondo si calcola è il resto della divisione intera. Metodo di Euclide Pagina 71

72 Codifica del metodo di Euclide con I resti per il calcolo del MCD int main () { int x =...; int y =...; while ((x!= 0) && (y!= 0)) { if (x > y) x = x % y; else y = y % x; printf("mcd = %d\n", (x!= 0)? x : y); return 0; Pagina 72

73 Cicli annidati Il corpo di un ciclo può contenere a sua volta un ciclo, chiamato ciclo annidato. E possibile annidare un qualunque numero di cicli. int main () { int const NMAX = 10; int riga, colonna; for(riga = 1; riga <= NMAX; riga++) { return 0; Stampa della tavola pitagorica for(colonna = 1; colonna <= NMAX; colonna++) if(riga * colonna < 10) printf(" %d ", riga * colonna); else printf("%d ", riga * colonna); printf("\n"); Pagina 73

74 Output prodotto Pagina 74

75 Esempio di doppio ciclo: stampa di una piramide di asterischi il numero di iterazioni di un ciclo più interno può dipendere dall iterazione del ciclo più esterno Esempio stampa di una piramide di asterischi Per la stampa della generica riga r: stampa (altezza r) blank e (2 r 1) asterischi. Pagina 75

76 Codice piramide asterischi int altezza, riga, i; printf("altezza = "); scanf("%d", &altezza); printf("\n"); for (riga = 1; riga <= altezza; riga++) { // 1 iterazione per ogni riga della piramide for (i = 1; i <= altezza - riga; i++) printf(" "); // stampa gli spazi bianchi iniziali for (i = 1; i <= riga * 2-1; i++) printf("*"); // stampa la sequenza di asterischi printf("\n"); // va a capo: la riga e finita Pagina 76

77 Esecuzione piramide asterischi Pagina 77

78 Esempio: potenza con un doppio ciclo int main() { int base = 2; int esponente= 3; int risultato = 1; while (esponente > 0) { esponente--; // risultato = risultato * base int moltiplicando = risultato; int moltiplicatore = base; int prodotto = 0; while (moltiplicatore > 0) { moltiplicatore--; prodotto = prodotto + moltiplicando; risultato = prodotto; printf("%d\n", risultato); Pagina 78

79 Istruzioni di controllo del flusso Le istruzioni di controllo del flusso determinano la successiva istruzione da eseguire. Le istruzioni if-else, if, switch, while, for, do-while sono istruzioni di controllo del flusso di esecuzione. Esse non permettono, però, di stabilire in modo arbitrario la prossima istruzione da eseguire, ma forniscono una strutturazione del programma che determina il flusso di esecuzione. Pagina 79

80 Istruzioni di salto break (salto all'istruzione successiva al ciclo o allo switch corrente) continue (salto alla condizione del ciclo) goto (salto all'istruzione etichettata) Anche l'istruzione return può essere usata per modificare il flusso di esecuzione, nelle funzioni definite. Pagina 80

81 Istruzione break per uscire da un ciclo (1/2) break permette di uscire prematuramente da un istruzione switch, while, for o do-while. double a; int i; for (i = 0; i < 10; i++) { printf("immetti un reale non negativo: "); scanf("%lf", &a); if (a >= 0) printf("%f\n", sqrt(a)); else { printf("errore\n"); break; Pagina 81

82 Istruzione break per uscire da un ciclo (2/2) Nota: nel caso di cicli annidati o di switch annidati dentro un ciclo, l esecuzione di un break permette di uscire da un solo livello. Pagina 82

83 Istruzione break in doppio ciclo int main() { int a; int i, j; printf("immetti un intero non negativo: "); scanf("%d", &a); for (i = 0; i < 10; i++) { printf("*"); for (j = 0; j < 10; j++) { if(a == 2) break; printf("*"); if (a >= 0) printf("%d\n", a); else { printf("errore\n"); break; Pagina 83

84 Esecuzione Pagina 84

85 Rimozione del break (1/3) L esecuzione di un istruzione break altera il flusso di controllo. Quando viene usata nei cicli: si perde la strutturazione del programma si guadagna in efficienza rispetto ad implementare lo stesso comportamento senza fare uso del break. In generale, è sempre possibile eliminare un istruzione break. Pagina 85

86 Rimozione del break (2/3) while (condizione) { istruzioni-1 if (condizione-break) break; istruzioni-2 equivale a int finito = 0; //condizione finito = false while (condizione &&!finito) { istruzioni-1 if (condizione-break) finito = 1; //condizione finito = true else { istruzioni-2 Pagina 86

87 Rimozione del break (3/3) double a; int errore = 0; int i; for (i = 0; (i < 10) &&!errore; i++) { printf("immetti un reale non negativo: "); scanf("%lf", &a); if (a > 0) printf("%f\n", sqrt(a)); else { printf("errore\n"); errore = 1; Pagina 87

88 Istruzione continue L istruzione continue si applica solo ai cicli e comporta il passaggio alla successiva iterazione del ciclo, saltando le eventuali istruzioni che seguono nel corpo del ciclo. int i; for (i = 0; i < n; i++) { if (i % 2 == 0) continue; printf("%d\n", i); Pagina 88

89 Uso errato di continue Nota: Un possibile uso di continue è all interno di un ciclo di lettura, nel quale vogliamo effettuare un elaborazione sui dati letti solo se è verificata una determinata condizione. Bisogna però assicurarsi che ad ogni iterazione del ciclo venga in ogni caso letto il prossimo valore. Altrimenti il ciclo non termina. Esempio: leggi il prossimo dato ; while (condizione) { if (condizione-sul-dato-corrente ) continue; // ERRORE! viene saltata la lettura del dato elabora il dato; leggi il prossimo dato ; Pagina 89

90 Esempio su continue Cosa stampa questo programma? #include <stdio.h> int main() { int i; for (i = 0; i < 5; i++) { if(i == 3) { continue; printf("i = %d\n", i); return 0; Pagina 90

91 Istruzione di salto goto L istruzione di salto deriva dal linguaggio macchina dove ha un ruolo fondamentale per consentire la realizzazione dei cicli. Il teorema di Böhm e Jacopini ha mostrato che essa non è necessaria ai fini della completezza del linguaggio. L istruzione di salto comporta una interruzione del flusso dell esecuzione del programma, che prosegue con l istruzione specificata nel goto. Per consentire il salto, le istruzioni possono avere delle etichette: etichetta : istruzione-ciclo; Le etichette devono essere degli identificatori. Pagina 91

92 Sintassi e semantica di goto Sintassi goto etichetta etichetta è un identificatore che deve individuare una istruzione del programma. Semantica L'esecuzione del programma prosegue con la istruzione specificata dall'etichetta Pagina 92

93 Esempio sul goto int i = 0; int x; while (i < 100) { printf("inserisci dato: "); scanf("%d", &x); if (x < 0) goto errore; i++; errore: printf("errore nei dati, programma interrotto\n"); Pagina 93

94 Esecuzione Pagina 94

95 Nota sul goto L uso di etichette e di istruzioni goto è considerato come cattiva pratica di programmazione e va riservato a casi particolari. Pagina 95

96 Esempio su break e continue int x, i; for(;;) { printf("inserisci un intero non negativo\n"); i = scanf("%d", &x); printf("valore di ritorno scanf: %d\n", i); if(x < 0) { printf("ho detto non negativo\n"); continue; else if(i!= 1){ if(i == 0) printf("formato non corretto. addio\n"); else if(i == EOF) printf("ciao ciao\n"); break; printf("ho letto %d\n", x); Pagina 96

97 Valore di ritorno scanf int scanf ( const char * format,... ); Read formatted data from stdin Reads data from stdin and stores them according to the parameter format into the locations pointed by the additional arguments. The additional arguments should point to already allocated objects of the type specified by their corresponding format tag within the format string. Return Value On success, the function returns the number of items successfully read. This count can match the expected number of readings or fewer, even zero, if a matching failure happens. In the case of an input failure before any data could be successfully read, EOF is returned. Pagina 97

98 Esercizio su break e continue Si chiede di realizzare un programma in grado di leggere da tastiera dei valori int ed elaborarli in accordo con le seguenti condizioni: Se il valore che viene letto è negativo, si vuole stampare un messaggio di errore e terminare il programma. Se il valore letto è maggiore di 100, si vuole ignorarlo e continuare con il successivo valore in input. Se il valore è 0, si vuole terminare il ciclo con un messaggio di avvenuta terminazione corretta. Altrimenti si vuole stampare il doppio dell intero letto Pagina 98

99 Soluzione /* Viene letto un valore intero ed elaborato purché sia maggiore di 0 e minore di 100 */ while (scanf("%d", &value) == 1 && value!=0) { if (value < 0) { printf("valore non ammesso\n"); break; /* Abbandona il loop */ if (value > 100) { printf("valore non ammesso\n"); continue; // Torna nuovamente all'inizio del loop /*Elabora il valore letto*/ /*che e' sicuramente tra 0 e 100 */ printf("%d\n", 2 * value); printf("programma terminato con successo"); Pagina 99