{"id":6797,"date":"2011-04-27T14:21:26","date_gmt":"2011-04-27T12:21:26","guid":{"rendered":"http:\/\/www.devapp.it\/wordpress\/?p=6797"},"modified":"2012-09-08T18:47:29","modified_gmt":"2012-09-08T16:47:29","slug":"11-le-funzioni","status":"publish","type":"post","link":"https:\/\/www.devapp.it\/wordpress\/11-le-funzioni\/","title":{"rendered":"11. Le funzioni"},"content":{"rendered":"

\"corso-completo-c-le-funzioni-00\"<\/a> Ciao a tutti, dopo una breve “pausa” in cui abbiamo consolidato le informazioni fino ad ora acquisite tramite qualche esercizio pratico, iniziamo a parlare, con questa nuova lezione del nostro Corso Completo di Programmazione in C, di un argomento molto interessante. In questo articolo vorrei approfondire un concetto che in realt\u00e0 abbiamo gi\u00e0 trattato nella lezione 5<\/a>, ma poi nelle successive lezioni \u00e8 stato volutamente tralasciato. Sto parlando delle funzioni<\/strong>.<\/p>\n

Abbiamo gi\u00e0 imparato che un blocco di codice C ha questa sintassi:<\/p>\n

\r\nvalore_di_ritorno NOME_BLOCCO (parametro1, parametro2)\r\n\r\n{\r\n\r\n        operazioni nel blocco ;\r\n\r\n        operazioni nel blocco ;\r\n\r\n        ...\r\n\r\n        return VALORE ;\r\n\r\n}\r\n<\/pre>\n
ed in particolare il blocco principale (main) ha questa forma:<\/p>\n
\r\nint main(int argc, char **argv)\r\n\r\n{\r\n\r\n\/\/ Qui  possiamo eseguire il nostro codice.\r\n\r\n\/\/ Vi ricordo che le righe che iniziano con due \"\/\" sono commenti.\r\n\r\nreturn 0;        \r\n\r\n}\r\n<\/pre>\n
I valori tra le parentesi tonde sono i parametri della funzione, vengono separati da virgole e possono essere in numero variabile, da zero fino a 253… ma siete davvero sicuri di voler scrivere una funzione con 253 parametri???<\/p>\n
Ciascun blocco di questo tipo si chiama funzione, quindi anche il blocco main<\/em>, di fatto, costituisce una funzione, anche se di solito tale termine \u00e8 utilizzato per identificare tutti gli altri blocchi di codice eccetto il main.<\/p>\n
All’interno della funzione viene scritto del codice che in qualche modo dipende dai parametri presenti tra parentesi, cos\u00ec quando la funzione verr\u00e0 invocata (questo \u00e8 il termine appropriato quando viene utilizzata una funzione) il suo comportamento sar\u00e0 diverso a seconda dei parametri con i quali \u00e8 stata invocata.<\/p>\n
Non pensate di aver a che fare con un concetto nuovo, per chi tra di voi ha preso un voto pi\u00f9 alto del 4 in matematica il concetto di funzione dovrebbe essere gi\u00e0 ben chiaro, ma anche per tutti gli altri non dovrebbe essere difficile rendersi conto che tutto quello che ci circonda in qualche modo dipende dai parametri di ingresso…il comportamento del vostro ascensore dipende essenzialmente dal pulsante che avete pigiato, quindi possiamo ragionevolmente affermare che l’altezza raggiunta da un ascensore \u00e8 funzione del pulsante premuto.<\/p>\n
Dopo questa rischiosa divagazione, torniamo al nostro codice C e ci chiediamo: ma a cosa pu\u00f2 essere utile avere una (o pi\u00f9) funzioni all’interno dei nostri programmi in C?<\/p>\n
A due cose veramente importanti, cio\u00e8 risparmiare linee di codice (e quindi tempo) e organizzare in maniera ordinata il codice sorgente.<\/p>\n
Vediamolo subito con un esempio, supponiamo di dover scrivere un programma in C in cui avremo spesso a che fare con delle date e nel quale sar\u00e0 molto importante stabilire se un anno \u00e8 bisestile o meno.<\/p>\n
Per chi non lo ricorda un anno \u00e8 bisestile se \u00e8 divisibile per 4, con l\u2019eccezione che gli anni secolari (quelli divisibili per 100) che sono bisestili solo se divisibili per 400.<\/p>\n
Sono cio\u00e8 bisestili tutti gli anni la cui numerazione termina con le due cifre 04, 08, 12\u2026 fino a 96; gli anni che terminano con 00 sono bisestili solo se l\u2019anno \u00e8 divisibile per 400, cio\u00e8 il 1600, il 2000, il 2400 eccetera.<\/p>\n
Volete provare a trasformare questa condizione in un programma C? Forza non \u00e8 difficile, fermatevi un attimo e provate, ma non sbirciate la soluzione! Quando avete fatto continuate pure a leggere.<\/p>\n

\n*** PRIMA DI PROCEDERE PROVATE A RISOLVERE AUTONOMAMENTE IL PROBLEMA PROPOSTO ***<\/strong>
\n<\/center><\/p>\n
Per testare se un anno \u00e8 bisestile potremmo avere un approccio “ingenuo” tentando di tradurre dall’italiano al C<\/p>\n
\r\nint anno = 1980; \/\/digitiamo un anno di esempio.\r\n\r\nif (anno % 4 == 0 ) { \/\/testo se \u00e8 multiplo di 4\r\n\r\n        if ( anno % 100 != 0) { \/\/testo che non sia multiplo di 100\r\n\r\n        printf(\"L'anno %d \u00e8 bisesto\",anno);\r\n\r\n}\r\n\r\nelse { \/\/entra qui se \u00e8 multplo di 100\r\n\r\n        if (anno % 400 == 0) { \/\/verifico che sia multiplo di 400\r\n\r\n        printf(\"L'anno %d \u00e8 bisesto\", anno);\r\n\r\n}\r\n\r\n}\r\n\r\n}\r\n\r\nelse {\r\n\r\n        printf(\"L'anno %d non \u00e8 bisesto\", anno);\r\n\r\n}\r\n<\/pre>\n
Questo codice \u00e8 paurosamente prolisso, direi che tutto pu\u00f2 essere condensato in queste poche righe:<\/p>\n
\r\nint anno = 1980;\r\n\r\n\/* spiegazione: se l'anno \u00e8 multiplo di 4 AND non \u00e8 multiplo di 100 OR\r\n\r\n* l'anno \u00e8 multiplo di 400 allora \u00e8 bisestile.\r\n\r\n* Commentate sempre le condizioni piuttosto complesse, risparmierete tempo\r\n\r\n* successivamente.\r\n\r\n*\/\r\n\r\nif (((anno % 4 == 0 && anno % 100 != 0) || anno % 400 == 0)) {\r\n\r\n        printf(\"Anno bisesto\");\r\n\r\n}\r\n\r\nelse {\r\n\r\n        printf(\"Anno non bisesto\");\r\n\r\n}\r\n<\/pre>\n
Anche se cos\u00ec condensato non \u00e8 comodo scrivere tutto questo codice ogni volta che abbiamo bisogno di testare se un anno \u00e8 bisestile o meno, inoltre cosa succederebbe se, dopo aver scritto 100 volte questo test nel nostro programma, ci accorgessimo che contiene un errore? Saremmo costretti a correggere tutte le 100 istanze…una vera seccatura e sicura fonte di errori. Perch\u00e9 non creare quindi una funzione, che accetti come parametro un numero intero che rappresenti l’anno da testare e restituisca il valore “VERO” se l’anno \u00e8 bisestile e il valore “FALSO” se non lo \u00e8? Vi ricordo che in ANSI C non esiste una tipo di variabile specifica per memorizzare il concetto di “VERO” e “FALSO” ma il compilatore C accetta come “VERO” un qualsiasi valore numerico diverso da 0, mentre 0 significa “FALSO”.<\/p>\n
Quindi la nostra funzione per testare la bisestivit\u00e0 \ud83d\ude00 di un anno accetter\u00e0 come parametro un numero intero (l’anno da testare) e restuitir\u00e0 un numero intero. Secondo lo schema precedente allora la struttura dovrebbe essere la seguente:<\/p>\n
\r\nint isLeapYear(int anno) \/\/mi scuso per gli inglesismi :)\r\n\r\n{\r\n\r\n        return 0;\r\n\r\n}\r\n<\/pre>\n
non ci resta che aggiungere il codice precedente ed avremo creato la nostra prima funzione:<\/p>\n
\r\nint isLeapYear(int anno)\r\n\r\n{\r\n\r\n        if (((anno % 4 == 0 && anno % 100 != 0) || anno % 400 == 0)) {\r\n\r\n                return 1; \/\/restituiamo TRUE visto che l'anno \u00e8 bisesto\r\n\r\n}\r\n\r\nelse {\r\n\r\n                return 0; \/\/restituiamo FALSO\r\n\r\n}\r\n\r\n}\r\n<\/pre>\n
Una piccola precisazione, quando in una funzione viene eseguita l’istruzione return tutte le istruzioni successive non vengono eseguite, si dice che la funzione “esce restituendo il valore al chiamante”.<\/p>\n
Questa funzione potr\u00e0 essere utilizzata all’interno del nostro programma per tenere tutto il codice pi\u00f9 ordinato e per centralizzare il calcolo in un singolo punto, guardate questo esempio:<\/p>\n
\r\nint anno = 1980;\r\n\r\nif ( isLeapYear(anno) ) {\r\n\r\n        printf(\"Anno bisestile\");\r\n\r\n}\r\n\r\nelse {\r\n\r\n        printf(\"Anno non bisestile\");\r\n\r\n}\r\n<\/pre>\n
non notate com’\u00e8 pi\u00f9 chiaro, sintetico e intuibile? Il codice sorgente completo lo trovate qui<\/a>.<\/p>\n
In alcuni casi le funzioni non necessitano di valori di ritorno e\/o di parametri in ingresso, in quel caso \u00e8 buona norma specificare questa situazione inserendo la parola “void” (come ad esempio questa funzione, che non restituisce alcun valore ma accetta in input un numero intero che specifica quanti  ” * ” stampare.<\/p>\n
\r\nvoid printStar(int numStar) {\r\n\r\n        int i ;\r\n\r\n        for ( i = 0; i < numStar; i++) {\r\n\r\n        printf(\"*\");\r\n\r\n}\r\n\r\n}\r\n<\/pre>\n
NOTA:<\/strong> in alcuni linguaggi di programmazione esistono delle differenze tra le funzioni e le procedure, una procedura \u00e8 una funzione che non restituisce alcun valore. In questo caso la funzione che abbiamo appena visto verrebbe chiamata procedura in un altro linguaggio. In C non viene fatta questa differenza.<\/p>\n
Questa funzione, invece, non accetta valori in input e non restituisce alcun valore<\/p>\n
\r\nvoid sayHello(void) {\r\n\r\n        printf(\"Ciao e buono studio!\");\r\n\r\n}\r\n<\/pre>\n
Queste funzioni potrebbero sembrare inutili, ed infatti lo sono, ma sottolineo per l'ennesima volta che in un programma non dovrebbero esserci mai due righe uguali, tutte le ripetizioni dovrebbero essere gestite tramite apposite funzioni, cos\u00ec se c'\u00e8 un errore c'\u00e8 un unico posto dove andare a correggerlo.<\/p>\n
I parametri<\/h4>\n
Cosa succede se una funziona modifica il valore che le \u00e8 stato passato come parametro? Se provo ad eseguire questo codice:<\/p>\n
\r\n#include \r\n\r\nvoid incrementa(int value) {\r\n\r\n        value = value + 10;\r\n\r\n}\r\n\r\nint main (int argc, const char * argv[])\r\n\r\n{\r\n\r\n        int k = 5;\r\n\r\n        printf(\"Valore prima di eseguire incrementa %d\\n\",k);\r\n\r\n        incrementa(k);\r\n\r\n        printf(\"Valore dopo aver eseguito incrementa %d\\n\",k);\r\n\r\n           return 0;\r\n\r\n}\r\n<\/pre>\n
Sembrerebbe chiaro che la funzione \"incrementa\" si occupi di aggiungere 10 al valore della variabile passata come parametro, ma soprendentemente l'output del programma sar\u00e0:<\/p>\n

\nValore prima di eseguire incrementa 5
\nValore dopo aver eseguito incrementa 5
\n<\/code><\/p>\n
sembra che non ci sia stato alcun incremento, come mai?<\/p>\n
Presto detto: il linguaggio C utilizza una tecnica denominata \"passaggio parametri per valore\"  secondo la quale quello che succede quando viene invocata la funzione incrementa(k)<\/em> \u00e8 che il valore della variabile k<\/em> viene copiato nella variabile value<\/em> della funzione. Tutte le modifiche che la funzione apporter\u00e0 quindi alla variabile value<\/em> non si ripercuoteranno quindi sulla variabile k<\/em>, perch\u00e9 non c'\u00e8 nessun legame tra le due, ecco perch\u00e9 quindi il valore di k<\/em> \u00e8 lo stesso sia prima che dopo aver invocato la funzione incrementa(k)<\/em>.<\/p>\n
Quindi \u00e8 impossibile scrivere delle funzioni che modifichino il valore delle variabili passate come parametri? La risposta \u00e8 no, non \u00e8 impossibile, ma al momento non abbiamo ancora parlato dei puntatori e quindi la spiegazione \u00e8 rimandata a tra qualche lezione.<\/p>\n
Le funzioni ricorsive<\/h4>\n
\"corso-completo-c-le-funzioni-01\"<\/a> Sicuramente avrete gi\u00e0 visto l'immagine qui affianco, affascinante, vero?<\/p>\n
Non \u00e8 una illusione ottica, ma la migliore rappresentazione grafica che io abbia mai trovato del concetto di ricorsione.<\/p>\n
Personalmente mi ritengo molto affascinato dal concetto di ricorsione, e autori come Douglas Hofstadter con il suo G\u00f6del, Escher, Bach: un'eterna ghirlanda brillante e Anelli nell'io, artisti come Escher con i suoi quadri hanno accentuato il mio interesse verso qualsiasi cosa che abbia un comportamento ricorsivo.<\/p>\n
Non mancano poi esempi cinematografici come il recente inception oppure roba meno colta come South Park in cui producono un \"hamburger al quadrato\" utilizzando la carne di mucche nutrite con hambuger.<\/p>\n
Anche google ci scherza su, provate a cercare \"recursion\" su google inglese \ud83d\ude42<\/p>\n
Ma in fondo cos'\u00e8 la ricorsione? Wikipedia definisce algoritmo ricorsivo<\/a> come un algoritmo espresso in termini di se stesso...<\/strong> a questo punto di solito il cervello parte per la tangente, cercando di trovare il bandolo della matassa come nel quadro mani che si disegnano...non a caso viene spesso citata una frase \"Iterare \u00e8 umano, usare la ricorsione \u00e8 divino\"  [L. Peter Deutsch] perch\u00e9 l'utilizzo della ricorsione per la risoluzione di un problema, piuttosto che un approccio iterativo all'inizio pu\u00f2 sembrare incomprensibile.<\/p>\n
In questo momento non mi sembra il caso di dilungarmi in spiegazioni teoriche sul funzionamento della ricorsione oppure, devo ammetterlo, non mi sento in grado di spiegarlo in termini semplici senza poter gesticolare e scarabocchiare su una lavagna \ud83d\ude42 ma vorrei quantomeno fornirvi un esempio.<\/p>\n
Alcuni problemi pi\u00f9 di altri si prestano ad essere risolti con un approccio ricorsivo, primo tra questi \u00e8 il problema di calcolare il fattoriale di un numero.<\/p>\n
Wikipedia ci fornisce sempre la definizione:<\/p>\n
In matematica<\/a>, se n \u00e8 un intero positivo<\/a>, si definisce n fattoriale<\/a><\/strong> e si indica con n!<\/strong> il prodotto dei primi n<\/em> numeri interi positivi minori o eguali di quel numero.<\/p>\n
In termini pi\u00f9 pratici, con un esempio pratico: il fattoriale di 10 \u00e8 il prodotto di 1*2*3*4*5*6*7*8*9*10<\/p>\n
Per scivere un programma che calcoli il fattoriale di un numero possiamo utilizzare l'approccio iterativo, per esempio scrivendo questo codice:<\/p>\n
\r\nint fattoriale(int n)\r\n\r\n{\r\n\r\nint i,risultato=1;\r\n\r\nfor ( i=1 ; i<=n ; i++ ) {\r\n\r\n             risultato = risultato * i;\r\n\r\n}\r\n\r\nreturn risultato;\r\n\r\n}\r\n<\/pre>\n
Ma un approccio ricorsivo risulta pi\u00f9 elegante e rispecchia meglio la definizione matematica:<\/p>\n
\r\nint fattoriale(int n)\r\n\r\n{\r\n\r\nint risultato;\r\n\r\nif (n == 0) {\r\n\r\n        risultato = 1;\r\n\r\n}\r\n\r\nelse {\r\n\r\n        risultato = n * fattoriale(n-1); \/\/ ricorsione!!\r\n\r\n}\r\n\r\nreturn risultato;\r\n\r\n}\r\n<\/pre>\n
in questo esempio vediamo che la funzione richiama s\u00e8 stessa passando come parametro una volta n-1, questo \u00e8 il cuore della ricorsione, quello che avviene \u00e8 che il computer interrompe l'esecuzione della funzione \"principale\" ed inizia ad eseguire la funzione richiamata su n-1, a sua volta anche questa verr\u00e0 interrotta per calcolare via via il fattoriale di n-2, n-3 etc fino ad arrivare a calcolare fattoriale(0). A quel punto l'ultima funzione, finalmente, termina senza effettuare ulteriori chiamate ricorsive quindi la precedente pu\u00f2 finalmente chiudersi, cos\u00ec termina la precendente ancora e cos\u00ec via fino a quanto non termina la fattoriale(n-1) e la funzione principale pu\u00f2 finalmente fornire in return il risultato.<\/p>\n
Un secondo esempio che viene spesso risolto con al programmazione ricorsiva \u00e8 quello di calcolare l'n-esimo numero della serie di fibonacci. Questo perch\u00e9 gi\u00e0 nella definizione dei numeri di Fibonacci c'\u00e8 il concetto di ricorsione, infatti i numeri di fibonacci sono:<\/p>\n
0,1, 1, 2, 3, 5, 8, 13, 21, 34......<\/p>\n
la regola \u00e8 che i primi due sono 0 e 1, i termini successivi sono dati dalla somma dei due termini precedenti. In \"matematichese\":<\/p>\n
fb(0) = 0
\nfb(1) = 1
\nfb(n) = fb(n-1) + fb(n-2)<\/p>\n
possiamo notare quindi la natura ricorsiva della definizione.<\/p>\n
Se volessimo quindi scrivere in C una funzione per calcolare l'n-esimo numero della serie di fibonacci potremmo scrivere:<\/p>\n
\r\nint fibonacci(int n)\r\n\r\n{\r\n\r\nif (n==1) {\r\n\r\nreturn 0;\r\n\r\n}\r\n\r\nelse if (n==2) {\r\n\r\nreturn 1;\r\n\r\n}\r\n\r\n        else {\r\n\r\n                return fibonacci(n-1) + fibonacci(n-2);\r\n\r\n}\r\n\r\n}\r\n<\/pre>\n
Spero di  non avervi perso per strada e che siate arrivati fino in fondo alla lettura di questo capitolo!<\/p>\n
Esercizi<\/h4>\n
Prima di concludere questa lezione vorrei lasciarvi qualche esercizio, per le soluzioni come sempre vi faremo aspettare un p\u00f2 di giorni, magari la curiosit\u00e0 potrebbe spingervi intanto a provare a risolversi scrivendo quache riga di codice!<\/p>\n
    \n
  1. Scrivere un programma che utilizzi una funzione per stampare a schermo un quadrato composto da tutti \"+\". Inoltre la funzione dovr\u00e0 essere realizzata in moto tale che modificando un solo numero si possa ottenere un quadrato di \"+\" della dimensione preferita.<\/li>\n
  2. Scrivere un programma che utilizzi una funzione con due parametri, uno di tipo char<\/em> e uno di tipo int<\/em>, passando alla funzione un carattere e un numero la funzione dovr\u00e0 stampare un quadrato di lato uguale a tale numero e composto dal carattere passato come parametro.\n
    Ad esempio, chiamando la funzione in questo modo: <\/p>\n
    mia_funzione('A', 5) <\/p>\n
    il risultato dovr\u00e0 essere:<\/p>\n
    AAAAA
    \nAAAAA
    \nAAAAA
    \nAAAAA
    \nAAAAA<\/li>\n
  3. Scrivere un programma che preso in input un intero n calcoli con una funzione ricorsiva la sommatoria da 1 a n\n
    esempio: n = 10; 1+2+3+4+5+6+7+8+9+10 = ?<\/p>\n
    Consiglio: il suo calcolo \u00e8 analogo a quello per il fattoriale.<\/li>\n
    Alla prossima \ud83d\ude42<\/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":"
    Ciao a tutti, dopo una breve “pausa” in cui abbiamo consolidato le informazioni fino ad ora acquisite…<\/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":[593,588,724,723,241,726],"class_list":["post-6797","post","type-post","status-publish","format-standard","hentry","category-corso-completo-di-c","tag-corso-completo-di-c-2","tag-corso-di-c","tag-esempi-codice-programmazione-c","tag-esercizi-programmazione-c","tag-ignazio-calo","tag-le-funzioni-in-c"],"acf":[],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/posts\/6797","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=6797"}],"version-history":[{"count":11,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/posts\/6797\/revisions"}],"predecessor-version":[{"id":9487,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/posts\/6797\/revisions\/9487"}],"wp:attachment":[{"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/media?parent=6797"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/categories?post=6797"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/tags?post=6797"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}