Carlo Ghezzi, Gian Pietro Picco

Transcript

1 Funzioni Carlo Ghezzi, Gian Pietro Picco Dipartimento di Elettronica e Informazione Politecnico di M, Italy picco@elet.polimi.it

2 Analogia con la matematica Come nella matematica, con le funzioni C: Possiamo definire una funzione Esempio: la funzione min(x) min(x): un valore v dell'insieme X tale che per ogni elemento w di X risulta v <= w e poi successivamente impiegarla nei nostri ragionamenti tutte le volte che ci serve Ai fini della programmazione, i vantaggi sono: Astrazione esprimere in modo sintetico operazioni complesse Riusabilità scrivere una sola volta codice usato più volte

3 Un esempio motivante #define MAXNUMMOV 10000; typedef struct { int giorno; int mese; int anno; Data; typedef struct { char causale[100]; Data data; float importo; Movimento; typedef struct { int nummovimenti; Movimento dati[maxnummov]; ElencoMovimenti; ElencoMovimenti entrate; ElencoMovimenti uscite; float saldo; Come calcolare il totale delle entrate?...e il totale delle uscite?

4 Un esempio motivante Potremmo scrivere: int i; float totentrate, totuscite; totentrate = 0; for(i=0; i<entrate.nummovimenti; i++) { totentrate += entrate.dati[i].importo; totuscite = 0; for(i=0; i<uscite.nummovimenti; i++) { totuscite += uscite.dati[i].importo; saldo = totentrate totuscite;

5 Sottoprogrammi Ma ci piacerebbe di più scrivere: saldo = tot(entrate) tot(uscite); mettendo a fattor comune il codice simile Ma per fare questo dobbiamo definire un sottoprogramma che calcola tot Si tratta di un programma asservito al programma principale Il sottoprogramma deve essere prima di tutto definito e poi può essere invocato (chiamato) cioè attivato per calcolare i risultati richiesti I sottoprogrammi possono essere di due tipi: funzioni restituiscono un valore al chiamante procedure svolgono un compito per il chiamante ma non restituiscono un valore specifico, bensì void

6 Un esempio di funzione #include <stdio.h> float tot(elencomovimenti mov); main() {... saldo = tot(entrate) tot(uscite); float tot(elencomovimenti mov) { int i; float totale; totale = 0; for(i=0; i<mov.nummovimenti; i++) { totale += mov.dati[i].importo; return totale; valore di ritorno dichiarazione variabili locali dichiarazione di funzione definizione di funzione

7 Struttura di un programma Direttive al precompilatore (#include, #define, ) Dichiarazione elementi condivisi da tutto il programma (programma principale main e sottoprogrammi) costanti, tipi, variabili,... Definizioni di sottoprogrammi cominciando dal programma principale main main è di fatto una funzione particolare

8 Definizione delle funzioni: ecnico Definizione delle funzioni: sintassi La definizione di una funzione è composta da: Una testata (o header), che contiene informazioni rilevanti ai fini di un uso corretto della funzione e cioè: Tipo del risultato (il codominio della funzione) Identificatore del sottoprogramma Lista di dichiarazioni degli argomenti della funzione (il dominio della funzione) Un blocco, detto corpo (o body) della funzione A sua volta, il corpo della funzione è costituito da: Una parte dichiarativa, detta parte dichiarativa locale, che contiene le variabili necessarie all esecuzione Una parte esecutiva, che contiene le istruzioni che costituiscono il corpo vero e proprio

9 Esempio testata corpo tipo parametro argomenti di ritorno identificatore funzione (parametri formali) int power(int base, int n) { int i, p=1; for(i=1; i<=n; i++) p*=base; return p; parte dichiarativa locale parte esecutiva

10 Parametri formali e attuali Gli argomenti della funzione, elencati nella testata, vengono chiamati i parametri formali della funzione I parametri attuali sono invece quelli con i quali la funzione viene attivata All atto dell invocazione della funzione, i parametri formali vengono inizializzati con i valori dei parametri attuali Parametri formali int power(int m, int n); main() {... printf("%d %d %d\n", i, power(2,i), power(3,i)); Parametri attuali

11 Risultato della funzione Il tipo del risultato (o parametro di ritorno) può essere sia un tipo predefinito che definito dall utente, tuttavia: Non può essere un array Può essere una struct anche se questa contiene array! Può essere un puntatore a un qualsiasi tipo E quindi al primo elemento di un array

12 Esempi di testate int FatturatoTotale(ElencoFatture par); typedef enum {false, true boolean; typedef char string[20]; typedef int sequenzainteri[20]; typedef float matreali[10][10]; // valuta se la stringa par1 precede la stringa par2 boolean precede(string s1, string s2); // stabilisce se par1 appartiene alla sequenza // di interi par2 boolean esiste(int n, sequenzainteri seq); // restituisce (un puntatore a) la matrice inversa di // quella ricevuta (tramite puntatore) matreali* matinversa (matreali *mat);

13 Dichiarazioni locali Nella parte dichiarativa locale vengono dichiarate variabili necessarie all esecuzione del sottoprogramma ma inutili al programma principale Seguono le stesse regole della parte dichiarativa di un programma, pertanto è possibile inserire nuove dichiarazioni di tipi costanti altri sottoprogrammi

14 Corpo della funzione Oltre alla parte dichiarativa locale contiene la parte esecutiva del sottoprogramma, che è costruita con stesse regole del programma principale contiene una o più istruzioni o blocchi In aggiunta, la parte esecutiva di una funzione può contenere un istruzione return accompagnata da un espressione (es. return x+y;) Il valore dell espressione diventa il risultato restituito dalla funzione Visto dal chiamante, il valore restituito è il valore della funzione in corrispondenza dei parametri di ingresso Tale istruzione termina l esecuzione del sottoprogramma, e restituisce il controllo al chiamante Possono esserci più istruzioni return ovviamente a ogni chiamata se ne esegue solo una, a seconda del flusso di esecuzione o nessuna In questo caso il sottoprogramma termina quando raggiunge e il risultato della funzione è indefinito

15 Chiamata (invocazione) ecnico di funzione La sintassi è ispirata alla notazione matematica una funzione, applicata ai suoi argomenti, fornisce un valore del suo codominio La chiamata di funzione sintatticamente è un espressione id_funzione(lista dei parametri attuali) I parametri attuali sono i valori degli argomenti ai quali viene applicata la funzione Ogni parametro è un espressione e quindi può contenere a sua volta un altra chiamata di funzione

16 Esempi x = sin(y) cos(pi alfa); //pi = π x = cos(atan(y) beta); risultatodigestione = fatturatototale(archiviofatture) sommacosti(archiviocosti); ordalf = precede(nome1, nome2);

17 Prototipi di funzione Una funzione può essere chiamata solo se precedentemente definita o dichiarata vincolo necessario per controllo di correttezza da parte del compilatore Definizione e dichiarazione non sono sinonimi La definizione comprende sia la testata che il corpo La dichiarazione (o prototipo) di funzione comprende soltanto la testata va posta nella parte dichiarativa globale o in quella della funzione che la chiama

18 Esempio int search (Tabella t, int k) { #include <stdio.h> int n; n; int result = -1; #define SIZE 100 for (n = 0; n < t.actualsize; n++) //Dichiarazioni globali if (t.contents[n]==k) typedef int array[size]; return result n; = n; typedef struct { return -1; result; int actualsize; array contents; Tabella; int search(tabella t, int k); //dichiarazione di funzione main() { //programma principale int i, pos, val; Tabella mytab; printf("dimensione della tabella (< %d): ", SIZE); scanf("%d", &mytab.actualsize); // no controllo for(i = 0; i < mytab.actualsize; i++) { printf("dammi un valore della tabella "); scanf("%d", &mytab.contents[i]); printf("dammi un valore da cercare in tabella "); scanf("%d", &val); pos = search(mytab, val); if (pos!=-1) printf("trovato in posizione %d\n", pos); else printf("valore non trovato in tabella!\n");

19 Esercizi Si scriva la funzione: boolean contiene(elencomovimenti mov, Movimento m) Si scriva la funzione: ElencoMovimenti estrai(elencomovimenti mov, int mese, int anno) Si scriva una funzione per calcolare la distanza in giorni tra due date

20 Modello di esecuzione Immaginiamo che esista una macchina dedicata ad eseguire il main e che, all invocazione di una funzione, ne venga creata un altra ad essa dedicata E così per ogni invocazione di funzione Tale macchina dedicata alla funzione ha una memoria ambiente) (ambiente che contiene: le variabili locali i parametri (che vengono trattate come variabili locali inizializzate all atto della chiamata) il risultato e viene distrutta alla terminazione della funzione Vedremo poi che in realtà una sola macchina può simulare questo comportamento

21 Esempio Effetto dell invocazione pos = search(mytab,val); mytab actualsize content t actualsize content val pos k n i Ambiente di main Ambiente di search Il passaggio dei parametri avviene per copia per copia da un ambiente all altro Vedremo che non sarà sempre necessariamente così

22 Un caso più complesso Nell invocazione x = sin(atan(y) acos(z)); l effetto complessivo è equivalente a: temp1 = atan(y); temp2 = acos(z); x = sin(temp1 temp2); catena di macchine dedicate

23 Come realizzare le ecnico macchine dedicate In pratica, la CPU e la memoria sono uniche Gli ambienti devono essere gestiti da una sola macchina, utilizzando la memoria del sistema Soluzione: gestione della memoria a pila (stack) Struttura dati LIFO (Last In First Out) L invocazione di una funzione comporta l allocazione di nuova memoria In cima allo stack La stessa macchina esegue il sottoprogramma Utilizzando i dati presenti nella pila Quando termina l esecuzione del sottoprogramma la memoria del suo ambiente può essere recuperata L ambiente puo essere rimosso dalla pila int x=0; int f1(int p){ return p+x; void f2(){ printf( %d,f1(x)); main(){ f2(); Ambiente globale Ambiente main f1() Ambiente f2() f1() Ambiente f1()

24 Il blocco Può comparire ovunque la sintassi consenta un istruzione È composto da due parti racchiuse tra graffe: una parte dichiarativa (facoltativa) una sequenza di istruzioni Due blocchi possono essere Annidati uno è interno all altro Paralleli entrambi interni a un terzo blocco, ma non annidati tra loro

25 Esempio int g1, g2; char g3; int f1(int par1, int par2); main(){ int a, b; int f2(int par3, int par1); if(a==0){ char a, c;... while(a==0){ float a;... /* Fine blocco2 */ /* Fine blocco1 */ /* Fine main */ int f1(int par1, int par2) { int d; { int e; g1, g2, g3 a, b a, c a par1, par2, d e main blocco1 blocco2 f1 blocco3... /* Fine blocco3 */ if(d==0){ int d;... /* Fine blocco4 */ /* Fine f1 */ int f2(int par3, int par4) { int f;... /* Fine f2 */ d par3, par4, f blocco4 f2

26 Ambiti di visibilità Con il termine visibile intendiamo che un elemento (variabile, funzione, ): può essere visto, cioè usato e referenziato tramite il suo identificatore valutato in un espressione usato nella parte sinistra di un assegnamento... Regole di visibilità: Gli elementi dichiarati nella parte dichiarativa globale: Sono visibili da tutte le funzioni (incluso main e procedure) e i blocchi del programma Gli identificatori predefiniti del linguaggio si intendono dichiarati nella parte dichiarativa globale Gli elementi dichiarati nella parte dichiarativa locale a una funzione Sono visibili dalle istruzioni del suo corpo, inclusi i blocchi Gli elementi dichiarati nella parte dichiarativa locale a un blocco Sono visibili dalle istruzioni del blocco (es. anche dai eventuali blocchi interni) Deroga (mascheramento): la dichiarazione di un elemento in una funzione o blocco maschera eventuali entità omonime più esterne

27 Vita delle variabili Va dalla creazione (allocazione della memoria) alla distruzione (rilascio della memoria deallocata) Esistono due classi di variabili: Statiche allocate una sola volta e distrutte al termine dell esecuzione del programma lo sono quelle globali fungono da canali di comunicazione tra funzioni Esistono anche variabili di funzione o blocco dichiarabili static ignoreremo in questo corso Dinamiche Vengono create e distrutte dinamicamente implicitamente dal sistema automatiche) (automatiche o esplicitamente dal programmatore, con appositi costrutti

28 Variabili automatiche Le variabili automatiche sono: create quando il flusso di esecuzione entra nel loro ambito di visibilità distrutte all uscita da tale ambito dichiarate nelle funzioni (inclusi parametri) e nei blocchi Nota: le variabili automatiche appartenenti a blocchi o funzioni eseguiti più volte: Sono allocate di volta in volta in celle differenti non vengono conservati i valori prodotti da precedenti esecuzioni della funzione o blocco

29 Procedure A volte si vuole definire un sottoprogramma che non si comporta come una funzione, ma semplicemente realizza una operazione o esegue un azione (senza ritornare un risultato) Esempi: stampare un elenco di fatture ordinare un array di interi leggere gli elementi di una tabella Per fare ciò, si può definire una funzione che ritorna il tipo predefinito void La dichiarazione void del tipo del risultato può essere trascurata in questo caso

30 Esempio int search (Tabella t, int k) { void int display(tabella n; int result t) = {-1; #include <stdio.h> intfor(n j; = 0; n < t.actualsize; n++) #define SIZE 100 printf("ecco if (t.contents[n]==k) la tabella letta:\n"); //Dichiarazioni globali for(j = 0; result j < t.actualsize; = n; j++) typedef int array[size]; printf("%d return result; ", t.contents[j]); typedef struct { printf("\n"); int actualsize; array contents; Tabella; Tabella mytab; void display(tabella t); int search(tabella t, int k); main() { int i, pos, val; printf("dimensione della tabella (< %d): ", SIZE); scanf("%d", &mytab.actualsize); // no controllo for(i = 0; i < mytab.actualsize; i++) { printf("dammi un valore della tabella "); scanf("%d", &mytab.contents[i]); display(mytab); printf("dammi un valore da cercare in tabella "); scanf("%d", &val); pos = search(mytab, val); if (pos!=-1) printf("trovato in posizione %d\n", pos); else printf("valore non trovato in tabella!\n");

31 Ambiente globale e side effects Esiste un ambiente globale, cioè esterno a tutte le macchine che rappresentano le funzioni Nel nostro caso, contiene mytab Le macchine di main, display e search possono accedere a tale ambiente globale Se lo modificano, possono generare un effetto collaterale (side effect) In questo caso, l effetto dell esecuzione di una funzione non è più confinato all interno del suo ambiente, ma può interessare variabili che vengono utilizzate da altre funzioni Ma come si può modificare un parametro (visto che ne viene fatta una copia nell ambiente del chiamato)?

32 Inserimento in tabella (errato) void insert (Tabella t, int el) { if(t.actualsize < SIZE) { t.actualsize++; t.contents[actualsize-1] = el; Che succede nel caso della chiamata: insert(mytab,27);?

33 rametri ecnico Passaggio parametri per indirizzo Finora i sottoprogrammi hanno potuto restituire un valore modificare l ambiente globale a loro volta passare parametri per valore Il passaggio per indirizzo costituisce un altro modo per far ottenere degli effetti sul programma chiamante attraverso la chiamata di funzione

34 Ottenere modifiche del ecnico Ottenere modifiche del parametro attuale 1. Parametro formale definito di tipo puntatore al tipo del parametro attuale desiderato 2. All'atto della chiamata viene passato per indirizzo (usando &) il parametro attuale deve essere una variabile, non una generica espressione 3. Nel corpo della funzione viene usato l'operatore di dereferenziazione * per accedere al parametro attuale desiderato mediante il suo indirizzo

35 Inserimento in tabella (corretto)... //Definizione della procedura insert void insert (Tabella *t, int el) { if(t->actualsize < SIZE) { t->actualsize++; t->contents[actualsize-1] = el;... int elem = 27;... //invocazione insert(&mytab, elem);...

36 Modello di esecuzione mytab actualsize t content elem el Ambiente di main Ambiente di insert

37 Esempio: ecnico scambio dei valori di due interi void swap (int *x, int *y) { int temp; temp = *x; *x = *y; *y = temp;... int a=10, b=20;... //invocazione swap(&a,&b); Effetto collaterale: Effetto collaterale: il valore dei parametri cambia in seguito all invocazione della funzione Ciò non accade con le funzioni matematiche

38 Effetti collaterali Una funzione C, a differenza delle funzioni matematiche, può non limitarsi a calcolare un valore nel suo codominio Infatti: può modificare l ambiente globale può modificare i parametri di ingresso, se passati per indirizzo Gli effetti collaterali rendono il programma meno comprensibile!!!

39 Esempi int x = 1;... int fun(int par) { return (par + x);... x = fun(1); x = fun(1); /* ora x vale 2 */ /* ora x vale 3 */ int fun(int *par){ *par++; return *par;... int y, z=0; y = fun(&z); /* modifica z */

40 Array come parametrip Gli array vengono trattati in modo particolare quando vengono usati come parametro attuale: viene passato per valore l indirizzo di base dell array, cioè l indirizzo del primo elemento Nota: gli elementi dell array non vengono copiati Nota: nel parametro formale Il parametro formale viene quindi trattato come un puntatore al primo elemento dell array e quindi in pratica l array è passato per indirizzo

41 Esempi Date le seguenti istruzioni: typedef double TipoArray[100]; TipoArray pippo; double ris;... ris = sum(pippo); le seguenti forme di header sono equivalenti: double sum(tipoarray a); double sum(double *a); double sum(double a[]);

42 Esempio /* Moltiplica gli elementi di un vettore di reali; n rappresenta la posizione dell ultimo elemento da moltiplicare */ double mul(double a[], int n) { int i; double ris = 1.0; for(i = 0; i < n; i ++) ris *= a[i]; return ris;

43 Esempio Algoritmo di bubblesort per l ordinamento di un array: void bubblesort (int a[], size) { for (i=0; i<size-1; i++) //porta in posizione i il minimo in i..size-1 for (j=size-1; j>i; j--) if(a[j] < a[j-1]) swap(&a[j], &a[j-1]);

44 struct come parametri Si possono passare sia per valore che per indirizzo Il risultato di una funzione può essere di tipo struttura Nota: anche se contiene un campo array viene fatta copia sia all atto della chiamata che all atto del passaggio del risultato

45 Esempio #include <stdio.h> typedef struct { int tab[3]; boh; void fun(boh y, int x[]); main() { boh a, b; int j; for(j=0; j<3; j++) a.tab[j] = j; b = a; a.tab[0] = 3; Output: printf("%d %d %d\n", a.tab[0], a.tab[1], a.tab[2]); printf("%d %d %d\n", b.tab[0], b.tab[1], b.tab[2]); fun(b, b.tab); printf("%d %d %d\n", a.tab[0], a.tab[1], a.tab[2]); printf("%d %d %d\n", b.tab[0], b.tab[1], b.tab[2]); void fun(boh y, int x[]){ y.tab[0] = 10; x[2] = 100; printf("%d %d %d\n", y.tab[0], y.tab[1], y.tab[2]); printf("%d %d %d\n", x[0], x[1], x[2]);

46 Passaggio parametri: pro e contro Per valore copia inefficiente se parametro ingombrante parametro attuale e formale occupano zone distinte di memoria non permette di restituire un risultato al chiamante Per indirizzo si copia solo l'indirizzo parametro attuale e formale fanno riferimento alle stesse celle di memoria permette di restituire risultati al chiamante tipo proprietà Tempo e spazio necessari Rischio effetti collaterali Restituzione valore al chiamante per valore alti no no per indirizzo bassi si si

47 Procedure e funzioni È facile trasformare funzione in procedura, rappresentando il risultato come un parametro aggiuntivo, passato per indirizzo Ad esempio, la funzione int f(int p1) {... return risultato;... y = f(x); diventa una procedura void f(int p1, int *p2) {... *p2 = risultato;... f(x,&y);