{"id":6709,"date":"2011-04-20T14:03:15","date_gmt":"2011-04-20T12:03:15","guid":{"rendered":"http:\/\/www.devapp.it\/wordpress\/?p=6709"},"modified":"2011-10-05T12:23:10","modified_gmt":"2011-10-05T10:23:10","slug":"9-istruzioni-iterative","status":"publish","type":"post","link":"https:\/\/www.devapp.it\/wordpress\/9-istruzioni-iterative\/","title":{"rendered":"9. Istruzioni iterative"},"content":{"rendered":"

\"corso-completo-c-istruzioni-iterative-00\"<\/a> In questa nona lezione del nostro corso completo di programmazione in C affronteremo un argomento piuttosto simpatico, parleremo delle istruzioni iterative.
\nQueste istruzioni permettono di ripetere una porzione di codice fino a quando non risulta vera una determinata condizione e, sebbene non indispensabili, sono alla base della programmazione.<\/p>\n

Istruzione while<\/h4>\n

L’istruzione while \u00e8 la pi\u00f9 semplice tra le istruzioni iterative, il suo compito \u00e8 quello di ripetere la porzione tra le parentesi graffe mentre una data condizione \u00e8 vera, quando la condizione cesser\u00e0 di essere vera il programma terminer\u00e0 il ciclo e riprender\u00e0 la sua normale esecuzione.<\/p>\n

La sintassi dell’istruzione while<\/em> \u00e8 la seguente:<\/p>\n

\r\nwhile (espressione) {\r\n\r\n        ...istruzioni...\r\n\r\n        ...istruzioni...\r\n\r\n}\r\n<\/pre>\n
Come nel caso del costrutto if<\/em> come espressione possiamo utilizzare qualsiasi cosa che possa essere vera o falsa.  Ad esempio potremmo scrivere:<\/p>\n
\r\nwhile (3 < 5 ) {\r\n\r\n        printf(\"tre \u00e8 minore di cinque!!\");\r\n\r\n}\r\n<\/pre>\n
Ma cos'ha di strano il codice che ho scritto? Che la sua esecuzione non terminer\u00e0 mai! l'espressione \"(3 < 5)\" verr\u00e0 valutata ad ogni iterazione e ad ogni iterazione risulter\u00e0 invariabilmente vera, quindi il codice entrer\u00e0 in un loop dal quale non riuscir\u00e0 mai ad uscire.\n\nBisogna quindi prestare attenzione che all'interno delle istruzioni del ciclo while ci siano sempre delle istruzioni in grado di rendere falsa l'espressione, solo cos\u00ec si potr\u00e0 essere sicuri di uscire dal ciclo, come in questo esempio.\n\n\n\n
\r\nint a = 1;\r\n\r\nwhile (a < 10) {\r\n\r\n        printf(\"a vale: %d\\n\", a);\r\n\r\n        a = a + 1;\r\n\r\n}\r\n<\/pre>\n
l'output di questo programma sar\u00e0:<\/p>\n

\na vale: 1
\na vale: 2
\na vale: 3
\na vale: 4
\na vale: 5
\na vale: 6
\na vale: 7
\na vale: 8
\na vale: 9
\n<\/code><\/p>\n
L'output si ferma a nove, perch\u00e9 alla nona iterazione il valore di a, all'istruzione \"a = a + 1\" diventa 10, ma all'iterazione successiva l'espressione \"a < 10\" non \u00e8 pi\u00f9 vera quindi il programma esce dal while<\/em> e riprende la sua normale esecuzione.<\/p>\n
Notare che nel while<\/em> se l'espressione \u00e8 gi\u00e0 falsa, le istruzioni contenute all'interno del blocco non vengono eseguite neanche una volta.<\/p>\n
In un diagramma di flusso il while<\/em> verrebbe cos\u00ec rappresentato:<\/p>\n

\n\"corso-completo-c-istruzioni-iterative-01\"<\/a>
\n<\/center><\/p>\n
Istruzione Do...while<\/h4>\n
Esiste una istruzione simile al while<\/em>, ma che pu\u00f2 risultare pi\u00f9 utile in certi casi, si chiama do...while<\/em> ed ha la seguente sintassi:<\/p>\n
\r\ndo {\r\n\r\n        ...istruzioni...\r\n\r\n        ...istruzioni...\r\n\r\n} while (espressione);\r\n<\/pre>\n
Io oserei definirei speculare il suo comportamento rispetto all'istruzione while<\/em>, infatti il do...while<\/em> valuta l'espressione dopo aver eseguito le istruzioni contenute nel blocco e, se l'espressione risulta vera, torna all'inizio del ciclo e lo riesegue, se invece \u00e8 falsa termina il ciclo.<\/p>\n
Poich\u00e9 quindi le istruzioni del blocco in questo caso vengono eseguite almeno una volta, anche se l'espressione \u00e8 falsa, si usa il do...while<\/em> quando si ha necessit\u00e0 di questo comportamento.<\/p>\n
Ecco la rappresentazione in un diagramma di flusso del do...while<\/em>:<\/p>\n

\n\"corso-completo-c-istruzioni-iterative-02\"<\/a>
\n<\/center><\/p>\n
Istruzione for<\/h4>\n
Ho lasciato per ultima l'istruzione iterativa pi\u00f9 versatile e pi\u00f9 complessa del linguaggio C. Qualcuno storcer\u00e0 il naso dicendo \"il for \u00e8 una istruzione complessa??\" beh, ma magari non proprio complessa, ma a volerne sfruttare tutte le capacit\u00e0 \u00e8 abbastana tricky.<\/p>\n
La sintassi base del for \u00e8 la seguente:<\/p>\n
\r\nfor (istruzioni di inizializzazione;\r\n       condizione di ripetizione del ciclo;\r\n       istruzioni di aggiornamento) {  \r\n   ...istruzione...;\r\n   ...istruzione...;\r\n   ...\r\n  ...istruzione...;\r\n}\r\n<\/pre>\n
Prima di entrare dentro il ciclo FOR<\/em> vengono eseguite le istruzioni di inizializzazione, poi inizia il ciclo e per ogni iterazione viene valutata (se presente) la condizione di ripetizione del ciclo, se tale espressione risulta vera allora vengono eseguite tutte le operazioni contenute all'interno del blocco, e al termine vengono eseguite le istruzioni di aggiornamento e ricomincia il ciclo.<\/p>\n
Facciamo un esempio classico:<\/p>\n
\r\nint i;\r\n\r\nfor (i = 0; i < 10; i = i + 1) {\r\n\r\n        printf(\"Valore di i: %d\",i);\r\n\r\n}\r\n<\/pre>\n
In questo esempio subito dopo aver dichiarato la variabile i<\/em> il programma esegue l'istruzione di inizializzazione (i = 0) che ha l'effetto di impostare a zero il valore della variabile i<\/em>. Poi viene valutata la condizione di ripetizione (i < 10) che risulta essere vera, quindi viene eseguita l'istruzione all'interno del blocco: printf(\"Valore di i: %d\",i);\n\nTerminate le istruzioni all'interno del blocco viene eseguita l'istruzione di aggiornamento (i = i + 1);\n\nQuello che rende particolarmente versatile il costrutto for \u00e8 che tutti  e tre i parametri sono opzionali e possono essere costituiti da pi\u00f9 di una singola istruzione. Questo pu\u00f2 portare ad avere cicli for molto complessi come questi:\n\n
<\/p>\n\n\n\n\n
\n
\r\nfor ( ; ; ) {\r\n\r\n        ...istruzioni...\r\n\r\n}\r\n<\/pre>\n<\/td>\n
\nCiclo infinito, non ci sono istruzioni di aggiornemento,equivale ad un \"while (true) { }\"\n<\/td>\n<\/tr>\n
\n
\r\nfor (printf(\"Start ciclo for\"), i = 0;\r\n\r\n   i < 100, printf(\"Valore di i %d\\n\",i); i = i + 1); {\r\n\r\n...nessuna istruzione...\r\n\r\n}\r\n<\/pre>\n<\/td>\n
\nl'output \u00e8 il seguente<\/p>\n

\nValore di i 1
\nValore di i 2
\nValore di i 3
\nValore di i 4
\nValore di i 5
\nValore di i 6
\nValore di i 7
\nValore di i 8
\nValore di i 9<\/p>\n
ma \u00e8 stato ottenuto utilizzando esclusivamente le istruzioni di inizializzazione a aggiornamento.\n<\/td>\n<\/tr>\n
\n
\r\nfor (i = 0, j = 1;\r\n\r\n   j < 10000;\r\n\r\n   printf(\"%d %d\\n\",i,j) , i = i + j , j = i + j) {\r\n\r\n  ...nessuna istruzione...\r\n\r\n }\r\n<\/pre>\n<\/td>\n
\nCome calcolare i numeri di fibonacci minori di 10000 utilizzando apparentemente solo un ciclo for :)\n<\/td>\n<\/tr>\n<\/table>\n
<\/center><\/p>\n
For<\/em> di questo genere sono vivamente sconsigliati, rendono impossibile la lettura del codice, li ho scritti qui e non mi aspetto che vi siano subito chiari, ma li ho inseriti solo per darvi l'idea di quanto il costrutto for<\/em> pu\u00f2 essere \"denaturato\" fino a farci stare dentro un intero programma.<\/p>\n
Adesso che conoscete il costrutto for<\/em> eccovi una vignetta da veri geek:<\/p>\n

\n\"corso-completo-c-istruzioni-iterative-03\"<\/a>
\n<\/center><\/p>\n
Questa volta vorrei lasciarvi con un paio di esercizi, siamo gi\u00e0 alla nona lezione ed \u00e8 proprio il momento che iniziate a picchiare sulla tastiera! Io sono un teorico come indole, ma se poi vogliamo programmare davvero bisogner\u00e0 iniziare a sporcarsi le mani!<\/p>\n
Gli esercizi sono questi:<\/p>\n
1) Far stampare a schermo un rettangolo composto da asterischi come quello qui in basso, il lato deve essere di 10 per 5 asterischi:<\/p>\n
**********
\n**********
\n**********
\n**********
\n**********<\/p>\n
2) Far stampare a schermo un triangolo composto da asterischi come quello qui in basso:<\/p>\n
*
\n**
\n***
\n****
\n*****
\n******
\n*******
\n********
\n*********<\/p>\n
3) Far stampare a schermo un triangolo composto da asterischi come quello qui in basso:<\/p>\n
**********
\n*********
\n********
\n*******
\n******
\n*****
\n****
\n***
\n**
\n*<\/p>\n
Vi do un piccolo aiuto, provate ad utilizzare due cicli for<\/em>, uno dentro l'altro.<\/p>\n
Alla prossima!!<\/p>\n
Letture consigliate:<\/h4>\n
\"C-Corso-Completo-di-Programmazione-kernighan-ritchie-devAPP\"<\/a> Il linguaggio C. Principi di programmazione e manuale di riferimento (Accademica) <\/strong><\/a>
\nBrian W. Kernighan - Dennis M. Ritchie<\/em>
\nEditore:<\/strong> Pearson | Lingua:<\/strong> Italiano | Brossura:<\/strong> 313 pagine
\nPrezzo Listino:<\/strong> EUR 27,00<\/del>
\nPrezzo Promozione:<\/strong> EUR 22,95 con Spedizione gratuita<\/p>\n
\"C-Corso-Completo-di-Programmazione-Deitel-Deitel-devAPP\"<\/a> C. Corso completo di programmazione<\/strong><\/a>
\nPaul J. Deitel - Harvey M. Deitel<\/em>
\nEditore:<\/strong> Apogeo | Lingua:<\/strong> Italiano | Brossura:<\/strong> 640 pagine
\nPrezzo Listino:<\/strong> EUR 39,00<\/del>
\nPrezzo Promozione:<\/strong> EUR 33,15 con Spedizione gratuita<\/p>\n

\n\"\"<\/a>
\n<\/center><\/p>\n","protected":false},"excerpt":{"rendered":"
In questa nona lezione del nostro corso completo di programmazione in C affronteremo un argomento piuttosto simpatico,…<\/p>\n","protected":false},"author":53,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[569],"tags":[714,593,588,716,241,713,715],"class_list":["post-6709","post","type-post","status-publish","format-standard","hentry","category-corso-completo-di-c","tag-ciclo-for-c","tag-corso-completo-di-c-2","tag-corso-di-c","tag-do-while-c","tag-ignazio-calo","tag-istruzioni-iterative-c","tag-while-c"],"acf":[],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/posts\/6709","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/users\/53"}],"replies":[{"embeddable":true,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/comments?post=6709"}],"version-history":[{"count":7,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/posts\/6709\/revisions"}],"predecessor-version":[{"id":7813,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/posts\/6709\/revisions\/7813"}],"wp:attachment":[{"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/media?parent=6709"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/categories?post=6709"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/tags?post=6709"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}