Tecniche della Programmazione, lez.9

(1)

Tecniche della Programmazione, M.Temperini - lezione 9 - funzioni

Tecniche della Programmazione, lez.9

Funzioni e programmazione modulare

(2)

Sappiamo gia’ che il programma e’ composto da una collezione di … parti …

#include <stdio.h>

int main () { int n=4;

…

printf ("stampiamo n ... %d\n", n);

…

printf ("\nFINE programma\n");

return 0;

}

1) Main program: realizzato da int main() { …}

2) Funzioni di libreria: ottenute con le inclusioni di file header

- il programma principale ‘’chiama’’ una funzione di libreria, ‘’scrivendo‘’

il suo nome e aggiungendo dei parametri che verranno usati durante l’esecuzione della funzione

3) … … …

What’s Modulo?

(3)

Sappiamo gia’ che il programma e’ composto da una collezione di … parti …

#include <stdio.h>

int main () { int n=4;

…

printf ("stampiamo n ... %d\n", n);

…

printf ("\nFINE programma\n");

return 0;

}

1) Main program: realizzato da int main() { …}

2) Funzioni di libreria: ottenute con le inclusioni di file header

- il programma principale ‘’chiama’’ una funzione di libreria, ‘’scrivendo‘’ il suo nome e aggiungendo dei parametri che verranno usati durante l’esecuzione della funzione 3) … … …

What’s Modulo?

Per poter usare le funzioni standard di I/O

(4)

Sappiamo gia’ che il programma e’ composto da una collezione di … parti …

#include <stdio.h>

int main () { int n=4;

…

printf ("stampiamo n ... %d\n", n);

…

printf ("\nFINE programma\n");

return 0;

}

1) Main program: realizzato da int main() { …}

2) Funzioni di libreria: ottenute con le inclusioni di file header

- il programma principale ‘’chiama’’ una funzione di libreria, ‘’scrivendo‘’ il suo nome e aggiungendo dei parametri che verranno usati durante l’esecuzione della funzione 3) … … …

What’s Modulo?

Chiamata della funzione printf (che, per via dell’include, e’ ‘’nota al compilatore’’)

Parametri della chiamata:

- "stampiamo n ... %d\n"

- n

Argomenti e' un sinonimo spesso usato per "parametri"

(5)

Sappiamo gia’ che il programma e’ composto da una collezione di … parti …

#include <stdio.h>

int main () { int n=4;

…

printf ("stampiamo n ... %d\n", n);

…

printf ("\nFINE programma\n");

return 0;

}

1) Main program: realizzato da int main() { …}

2) Funzioni di libreria: ottenute con le inclusioni di file header

- il programma principale ‘’chiama’’ una funzione di libreria, ‘’scrivendo‘’

il suo nome e aggiungendo dei parametri che verranno usati durante l’esecuzione della funzione

3) Funzioni definite dal programmatore, nel medesimo file della main(), o anche in altri file.

What’s Modulo?

(6)

#include <stdio.h>

int main () { int n=4;

…

printf ("stampiamo n ... %d\n", n);

…

printf ("\nFINE programma\n");

return 0;

}

1) Main program: realizzato da int main() { …}

2) Funzioni di libreria: ottenute con le inclusioni di file header

- il programma principale ‘’chiama’’ una funzione di libreria, ‘’scrivendo‘’ il suo nome e aggiungendo dei parametri che verranno usati durante l’esecuzione della funzione

3) Funzioni definite dal programmatore, nel medesimo file della main(), o anche in altri file.

3.1) Le funzioni sono anche chiamate ‘’moduli’’ del programma:

- corrispondono a ‘’sottoprogrammi’’, ciascuno dei quali risolve, quando viene chiamato ad essere eseguito, un sottoproblema del problema generale affrontato dal programma

3.2) Il main program int main() e’ anche lei una funzione

3.3) Tutti i moduli vengono compilati (o sono gia’ compilati, come succede per le funzioni di libreria ), e poi, mediante linking, si ottiene il programma rilocabile (e poi eseguibile)

What’s Modulo? Funzioni definite dal programmatore

(7)

Sappiamo gia’ che il programma e’ composto da una collezione di oggetti …

#include <stdio.h>

int main () { int n=4;

…

printf ("stampiamo n ... %d\n", n);

…

printf ("\nFINE programma\n");

return 0;

}

- Main program: realizzato da int main() { …}

- Funzioni di libreria: ottenute con le inclusioni di file header

- il programma principale ‘’chiama’’ una funzione di libreria, scrivendo il suo nome e aggiungendo dei parametri che verranno usati durante l’esecuzione della funzione

- (Funzioni definite dal programmatore, nel medesimo file della main(), o anche in altri file).

- Le funzioni sono anche chiamate ‘’moduli’’ del programma

What’s Modulo?

Le funzioni di libreria risolvono sottoproblemi "generali", sottoproblemi che e’ ben noto possono presentarsi, sono previsti, e quindi sono anche gia’ pre-risolti …

Ad esempio, le funzioni rese disponibili da <math.h> permettono di eseguire calcoli matematici con una semplice chiamata di funzione:

printf ("stampiamo la radice di val ... %f\n", sqrt(val));

printf ("n alla m … %d\n", exp(n,m));

printf ("valore assoluto di p … %d\n", fabs(p));

Un problema particolare puo’ presentare invece un sottoproblema non generale, o comunque meno generale della stampa di dati o del calcolo della radice quadrata … per quel problema non c’e’

gia’ una soluzione disponibile tramite una funzione di libreria …

allora il programmatore puo’ (o deve) programmare una soluzione al sottoproblema in una funzione definita dal programmatore ….

Ad esempio un programma che calcola molti MCD puo’ aver bisogno di una funzione

che calcoi l’MCD di due numeri dati: chianiamola miaFunzioneMCD. Se tale funzione viene progettata ed implementata, allora poi sara’ possibile chiamarla in esecuzione ogni volta che serve, cosi’ come faremmo con sqrt().

maxComunDiv = miaFunzioneMCD(n,m) QUESTE SONO Chiamate di funzioni

… di libreria, ma comunque funzioni …

l'esecuzione della chiamata consiste nella esecuzione della funzione sui dati forniti dai parametri

la chiamata svolge il ruolo di una ESPRESSIONE … il valore risultante viene usato nel contesto in cui la chiamata è stata fatta

Negli esempi sopra le chiamate producono un valore che viene stampato, ma una chiamata puo' essere anche fatta in altri contesti …

ad esempio in una istruzione di assegnazione … rad = sqrt(val);

ma può anche direttamente essere una istruzione stampaMenu();

Altre frecce? Altri esempi?

(8)

Sappiamo gia’ che il programma e’ composto da una collezione di oggetti …

#include <stdio.h>

int main () { int n=4;

…

printf ("stampiamo n ... %d\n", n);

…

printf ("\nFINE programma\n");

return 0;

}

- Main program: realizzato da int main() { …}

- Funzioni di libreria: ottenute con le inclusioni di file header

- il programma principale ‘’chiama’’ una funzione di libreria, scrivendo il suo nome e aggiungendo dei parametri che verranno usati durante l’esecuzione della funzione

- (Funzioni definite dal programmatore, nel medesimo file della main(), o anche in altri file).

- Le funzioni sono anche chiamate ‘’moduli’’ del programma: corrispondono a ‘’sottoprogrammi’’, ciascuno dei quali risolve, quando viene chiamato ad essere eseguito, un sottoproblema del problema generale affrontato dal programma

- ….

What’s Modulo?

printf ("stampiamo la radice di val ... %f\n", sqrt(val));

printf ("n alla m … %d\n", exp(n,m));

printf ("valore assoluto di p … %d\n", fabs(p));

Un problema particolare puo’ presentare invece un sottoproblema non generale, o comunque meno generale della stampa di dati o del calcolo della radice quadrata … per quel problema non c’e’

gia’ una soluzione disponibile tramite una funzione di libreria …

allora il programmatore puo’ (o deve) programmare una soluzione al sottoproblema in una funzione definita dal programmatore ….

Ad esempio un programma che calcola molti MCD puo’ aver bisogno di una funzione

che calcoi l’MCD di due numeri dati: chianiamola miaFunzioneMCD. Se tale funzione viene progettata ed implementata, allora poi sara’ possibile chiamarla in esecuzione ogni volta che serve, cosi’ come faremmo con sqrt().

maxComunDiv = miaFunzioneMCD(n,m) QUESTE SONO Chiamate di funzioni

l'esecuzione della chiamata consiste nella esecuzione della funzione sui dati forniti dai parametri

la chiamata svolge il ruolo di una ESPRESSIONE … il valore risultante viene usato nel contesto in cui la chiamata e' stata fatta

In questi esempi le chiamate producono un valore che viene stampato, ma una chiamata puo' essere anche fatta in altri contesti …

ad esempio in una istruzione di assegnazione … rad = sqrt(val);

ma può anche direttamente essere una istruzione stampaMenu();

printf( "…", … );

(in questi ultimi due casi, il valore prodotto dalla chiamata, se c'e', non viene usato dal programma …)

(9)

- ….

printf ("stampiamo la radice di val ... %f\n", sqrt(val));

printf ("n alla m … %d\n", exp(n,m));

printf ("valore assoluto di p … %d\n", fabs(p));

Un problema particolare puo’ presentare invece un sottoproblema non generale, o comunque meno generale della stampa di dati o del calcolo della radice quadrata … per quel problema non c’e’ gia’ una soluzione disponibile tramite una funzione di libreria

… allora il programmatore puo’ (o deve) programmare una soluzione al sottoproblema in

una funzione definita dal programmatore

….

Ad esempio un programma che calcola molti MCD puo’ aver bisogno di una funzione che calcoli l’MCD di due numeri dati: chiamiamola miaFunzioneMCD() .

Se tale funzione viene progettata ed implementata, allora poi sara’ possibile chiamarla in esecuzione ogni volta che serve, cosi’ come faremmo con sqrt().

maxComunDiv = miaFunzioneMCD(n,m)

What’s Modulo? Funzioni definite dal programmatore

(10)

#include <stdio.h>

...

definizione miaFunzioneMCD() . ...

int main () { ...

mxComDiv = miaFunzioneMCD(n,m);

...

return 0;

}

- Main program: realizzato da int main() { …}

- Funzioni di libreria: ottenute con le inclusioni di file header

- il programma principale ‘’chiama’’ una funzione di libreria, scrivendo il suo nome e aggiungendo dei parametri che verranno usati durante l’esecuzione della funzione - Funzioni definite dal programmatore, nel medesimo file della main(), o anche in altri - Le funzioni sono anche chiamate ‘’moduli’’ del programma: corrispondono a ‘’sottoprogrammi’’, file

ciascuno dei quali risolve, quando viene chiamato ad essere eseguito, un sottoproblema del problema generale affrontato dal programma

- Il main program int main() e’ anche lei una funzione

- Tutti i moduli vengono compilati (o sono gia’ compilati, come succede per le funzioni di libreria ), e poi, mediante linking, si ottiene il programma rilocabile (e poi eseguibile)

Funzioni def. dal programmatore

La funzione int main() e’ quella che usiamo per definire il programma principale cui stiamo lavorando.

Il programma principale e’ quello che organizza a piu’ alto livello la soluzione del problema.

Per risolvere sottoproblemi il programma principale chiama, ove serve, altre funzioni - ad essere eseguite

- e a produrre cosi’ un risultato che e’ la soluzione del sottoproblema

Quando il programma principale chiama una funzione, questa

«prende il controllo dell’esecuzione»

ed il programma principale si sospende.

Al termine dell’esecuzione della chiamata, il programma principale riprende la sua esecuzione dal punto in cui si era interrotto.

E questo vale per qualsiasi funzione (ogni funzione potrebbe chiamare in aiuto un’altra funzione, per risolvere un suo sottoproblema …) Terminazione della

funzione main()

Con «return» termina qualsiasi funzione

CHIAMATA

(11)

Vantaggi della programmazione per moduli

- RIUSO:

Avevamo da risolvere il problema A ; lo abbiamo risolto con un programma in cui abbiamo anche programmato una funzione f() che risolveva il sottoproblema SP . Ora stiamo risolvendo il problema B , in cui c’e’ il medesimo sottoproblema SP .

Fantastico! (se abbiamo programmato bene f() …) possiamo riusare f() anche nel programma che risolve B

- TEST

Un programma diviso in moduli può essere testato più efficientemente di un programma che mette in fila tutte le sue istruzioni per pagine e pagine … (more about that, in future)

- SVILUPPO IN SQUADRA

Se il programma viene progettato in modo da essere scomposto in moduli, ci

si può dividere il lavoro con migliori possibilità di successo …

(12)

Funzioni … f(x), f(x,y), …

Una funzione C e’ molto simile alla funzione matematica che siamo abituati a trattare … ecco due esempi … di funzioni matematiche

f: Dom Codom

a f(a)

f: AxBxC Codom (a,b,c) f(a,b.c)

NB La funzione e’ come una scatola che fa i calcoli con i parametri che le vengono

passati …

(13)

Funzioni … f(x), f(x,y), …

Una funzione C e’ molto simile alla funzione matematica che siamo abituati a trattare … ecco due esempi … di funzioni matematiche

d ∈ Dom f: Dom Codom f(d) ∈ Codom

a f(a)

d1 ∈ A

f(d1,d2,d3) ∈ Codom f: AxBxC Codom

(a,b,c) f(a,b.c) d2 ∈ B

d3 ∈ C

NB La funzione e’ come una scatola che fa i calcoli con i parametri che le vengono passati …

Nella "scatola" a,b,c sono nomi generici per i parametri:

- in generale, la funzione mappa (a,b,c) su f(a,b,c);

- quando eseguiamo il calcolo della funzione con d1,d2,d3 viene calcolato il

valore di f(d1,d2,d3) …

(14)

Funzioni …

funType functionName (paramType_1 param1, …, paramType_n param_n) {…}

Una funzione C e’ molto simile alla funzione matematica che siamo abituati a trattare …

d ∈ Dom f: Dom Codom f(d) ∈ Codom

d f(d)

d1 ∈ A

f(d1,d2,d3) ∈ Codom f: AxBxC Codom

(a,b,c) f(a,b.c) d2 ∈ B

d3 ∈ C In C

exp1

mcd(exp1,exp2) valore di tipo int int mcd (int n1, int n2)

exp2

mcd: int x int int

(n1, n2) mcd(n1,n2)

(15)

exp1

mcd(exp1,exp2) valore di tipo int int mcd (int n1, int n2)

exp2

Una funzione C e’ molto simile alla funzione matematica che siamo abituati a trattare …

In C

Parametri formali

Intestazione della funzione

d ∈ Dom f: Dom Codom f(d) ∈ Codom

v f(v)

d1 ∈ A

f(d1,d2,d3) ∈ Codom f: AxBxC Codom

(a,b,c) f(a,b.c) d2 ∈ B

d3 ∈ C

Funzioni …

funType functionName (paramType_1 param1, …, paramType_n param_n) {…}

(16)

exp1

mcd(exp1,exp2) valore di tipo int int mcd (int n1, int n2)

exp2

Una funzione C e’ molto simile alla funzione matematica che siamo abituati a trattare …

In C

Parametri attuali

devono essere valori di tipo uguale

a quello dei parametri formali)

Parametri formali chiamata

d ∈ Dom f: Dom Codom f(d) ∈ Codom

v f(v)

d1 ∈ A

f(d1,d2,d3) ∈ Codom f: AxBxC Codom

(a,b,c) f(a,b.c) d2 ∈ B

d3 ∈ C

Funzioni in C

(17)

exp1

mcd(exp1,exp2) valore di tipo int int mcd (int n1, int n2)

exp2

Una funzione C e’ molto simile alla funzione matematica che siamo abituati a trattare …

In C

chiamata Espressione di tipo int

d ∈ Dom f: Dom Codom f(d) ∈ Codom

v f(v)

d1 ∈ A

f(d1,d2,d3) ∈ Codom f: AxBxC Codom

(a,b,c) f(a,b.c) d2 ∈ B

d3 ∈ C

Parametri attuali

devono essere valori di tipo uguale a quello dei parametri formali)

Funzioni in C

(18)

Una funzione C e’ molto simile alla funzione matematica che siamo abituati a trattare …

In C

int n

mcd(n,m) valore

di tipo int int mcd (int n1, int n2)

int m

chiamata Espressione di tipo int

d ∈ Dom f: Dom Codom f(d) ∈ Codom

v f(v)

d1 ∈ A

f(d1,d2,d3) ∈ Codom f: AxBxC Codom

(a,b,c) f(a,b.c) d2 ∈ B

d3 ∈ C

Quando la FUNZIONE CHIAMANTE effettua la chiamata delle FUNZIONE CHIAMATA, la prima viene sospesa, la seconda viene eseguita.

Al termine della sua esecuzione, la FUNZIONE CHIAMATA fornisce alla FUNZIONE CHIAMANTE un valore (VALORE RESTITUITO DALLA CHIAMATA).

mxComDiv = miaFunzioneMCD(n,m) ;

Questo valore ‘’appare‘’ nel punto in cui e’ stata chiamata la funzione.

La chiamata della funzione e’ in pratica un’espressione, la cui valutazione fornisce il valore ottenuto (RESTITUITO) dall’esecuzione della funzione chiamata.

Parametri attuali

in questo caso due variabili (che vengono trattate come espressioni e valutate …)

Funzioni in C

(19)

Una funzione C e’ molto simile alla funzione matematica che siamo abituati a trattare …

In C

int n

mcd(n,m) valore

di tipo int int mcd (int n1, int n2)

int m

Parametri attuali

Parametri formali chiamata Espressione di tipo int Tipo del valore restituito

d ∈ Dom f: Dom Codom f(d) ∈ Codom

v f(v)

d1 ∈ A

f(d1,d2,d3) ∈ Codom f: AxBxC Codom

(a,b,c) f(a,b.c) d2 ∈ B

d3 ∈ C

valore restituito

Quando la FUNZIONE CHIAMANTE effettua la chiamata delle FUNZIONE CHIAMATA, la prima viene sospesa, la seconda viene eseguita.

Al termine della sua esecuzione, la FUNZIONE CHIAMATA fornisce alla FUNZIONE CHIAMANTE un valore (VALORE RESTITUITO DALLA CHIAMATA).

Questo valore ‘’appare‘’ nel punto in cui e’ stata chiamata la funzione.

La chiamata della funzione e’ in pratica un’espressione, la cui valutazione fornisce il valore ottenuto (RESTITUITO) dall’esecuzione della funzione chiamata.

Il tipo del valore restituito e’ definito nell’intestazione della funzione.

Funzioni in C

(20)

Scrivere l'intestazione di una funzione C, cube(), che, ricevendo un numero reale, d, calcola e restituisce il cubo di d.

Un sottoproblema: cubo



- Riceve un valore di tipo double

- Restituisce un valore di tipo double

double n n

³

(21)

Scrivere una funzione che, ricevendo un numero reale, d, calcola e restituisce il cubo di d.

- Riceve un valore di tipo double

- Restituisce un valore di tipo double

Un sottoproblema: cubo

double cube (double d)

(22)

Scrivere una funzione che, ricevendo un numero reale, d, calcola e restituisce il cubo di d.

- Riceve un valore di tipo double

- Restituisce un valore di tipo double Esempio di programma in cui usarla … int main () {

double num, cub;

printf("Gentile utente, dammi un …: ");

scanf("%lf", &num);

cub = cube(num);

printf("voila' ... %g", cub);

…

Un sottoproblema: cubo

double cube (double d)

Chiamata della funzione cube, con parametro attuale num;

La chiamata e’ un’espressione.

In questo caso e’ una sottoespressione dell’espressione di assegnazione.

Il valore restituito dalla sua valutazione, di tipo double, viene assegnato a cub.

(23)

Scrivere una funzione che, ricevendo un numero reale, d, calcola e restituisce il cubo di d.

- Riceve un valore di tipo double

- Restituisce un valore di tipo double Esempio di programma in cui usarla … int main () {

double num, cub;

printf("Gentile utente, dammi un …: ");

scanf("%lf", &num);

cub = cube( num );

printf("voila' ... %g", cub);

…

Un sottoproblema: cubo

double cube (double d)

Chiamata della funzione cube, con parametro attuale num.

La chiamata e’ un’espressione.

E anche num, il parametro attuale, e' un'espressione (la cui valutazione produce semplicemente il valore contenuto in num).

(24)

Sì, ma in questo caso e’ molto semplice:

La funzione usa il parametro per calcolare il cubo, e restituisce il valore calcolato al termine.

double cube (double d) { double ris;

**ris = ddd;**

return(ris);

}

OPPURE, anche

double cube (double d) { **return(ddd);**

}

E dove sarebbe la funzione cubo?

In quale libreria?

Ah … La devo fare io?

(25)

**/* programma che fa uso della funzione cube */**

#include <stdio.h>

double cube (double d) {

**return(ddd); /* autoesplicativo ... */**

}

int main () {

double num, cub;



printf("FINE\n");

return 0;

}

"Programma del cubo", completo

(26)

**/* programma che fa uso della funzione cube */**

#include <stdio.h>

double cube (double d) {

**return(ddd); /* autoesplicativo ... */**

}

int main () {

double num, cub;

printf("Gentile utente, … lo elevo al cubo: ");

scanf("%lf", &num);

cub = cube(num);

printf("voila' ... %g", cub);

printf("FINE\n");

return 0;

}

Programma del cubo, completo

(27)

**/* programma che fa uso della funzione cube */**

#include <stdio.h>

double cube (double d) {

**return(ddd); /* autoesplicativo ... */**

}

int main () {

double num, cub;

printf("Gentile utente, … lo elevo al cubo: ");

scanf("%lf", &num);

cub = cube(num);

printf("voila' ... %g", cub);

printf("FINE\n");

return 0;

}

Programma del cubo, completo

DEFINIZIONE della funzione cube - Tipo restituito: double

- Tipo del PARAMETRO FORMALE, double - Nome del PARAMETRO FORMALE, d - L’esecuzione di return termina la

funzione, restituendo alla FUNZIONE CHIAMANTE il valore d*d*d

(28)

**/* programma che fa uso della funzione cube */**

#include <stdio.h>

double cube (double d) {

**return(ddd); /* autoesplicativo ... */**

}

int main () {

double num, cub;

printf("Gentile utente, … lo elevo al cubo: ");

scanf("%lf", &num);

cub = cube(num);

printf("voila' ... %g", cub);

printf("FINE\n");

return 0;

}

Programma del cubo, completo

CHIAMATA della funzione cube

- PARAMETRO ATTUALE, il valore dell’espressione num - Il valore del PARAMETRO ATTUALE viene usato

durante l’esecuzione del codice della funzione;

- questo valore viene assegnato al PARAMETRO FORMALE d,

- In altre parole questo valore (parametro attuale) viene USATO AL POSTO del parametro formale nel codice della funzione.

**- quindi quando viene calcolato ddd, e’ il cubo del parametro attuale che viene calcolato,**

- cioe’ **(valore di num)(valore di num)(valore di num)**

FUNZIONE CHIAMANTE : la main()

(29)

**/* programma che fa uso della funzione cube */**

#include <stdio.h>

double cube (double d) {

**return(ddd); /* autoesplicativo ... */**

}

int main () {

double num, cub;

printf("Gentile utente, … lo elevo al cubo: ");

scanf("%lf", &num);

cub = cube(num);

printf("voila' ... %g", cub);

printf("FINE\n");

return 0;

}

Programma del cubo, completo

CHIAMATA della funzione cube

- PARAMETRO ATTUALE, il valore dell’espressione num

- Il valore del PARAMETRO ATTUALE viene usato durante l’esecuzione del

codice della funzione; questo valore viene assegnato al PARAMETRO FORMALE d, quindi quando viene calcolato d*d*d, e’ il cubo del parametro attuale che viene calcolato

Si’, l’abbiamo detto meglio nella slide precedente …

(30)

**/* programma che fa uso della funzione cube */**

#include <stdio.h>

double cube (double d) {

**return(ddd); /* autoesplicativo ... */**

}

int main () {

double num, cub;

printf("Gentile utente, … lo elevo al cubo: ");

scanf("%lf", &num);

cub = cube(num);

printf("voila' ... %g", cub);

printf("FINE\n");

return 0;

}

Programma del cubo, completo

CHIAMATA della funzione cube

- PARAMETRO ATTUALE, il valore dell’espressione num

- Il valore del PARAMETRO ATTUALE viene usato durante l’esecuzione del

codice della funzione; questo valore viene assegnato al PARAMETRO FORMALE d, quindi quando viene calcolato d*d*d, e’ il cubo del parametro attuale che viene calcolato

(31)

double cube (double d) {

**double ris;/* variabile locale per il calcolo del cubo */**

ris **= ddd;**

return(ris);

}

Il codice della funzione cube, e’ costituito da una sequenza di istruzioni strutturate, un blocco … come per la main().

In queste istruzioni vengono usate le variabili definite nel blocco (si

chiamano VARIABILI LOCALI) e i PARAMETRI FORMALI, per effettuare calcoli e produrre il risultato che la funzione dovrà restituire al momento della terminazione (return).

Variabili locali in una funzione

Il blocco di codice della funzione può contenere dichiarazioni di variabili;

( Tutto come nella main(), che infatti è una funzione … La main() è la funzione che viene chiamata ad essere

eseguita (aka invocata), PER PRIMA, all’atto della messa in esecuzione del programma eseguibile

)

(32)

double cube (double d) { int ris;

**ris = ddd;**

return(ris);

}

Componenti di una funzione

funType functionName (paramType_1 param1, …, paramType_n param_n) {…}

- Intestazione: double cube (double d) riassume i tipi e i nomi che dovranno essere usati nella chiamata

- Blocco: { … }: il codice che viene eseguito quando la funzione viene messa in esecuzione; contiene

- Istruzioni,

- Dichiarazioni di variabili (VARIABILI LOCALI)

- Una o più istruzioni return, che terminano l’esecuzione della funzione e provocano la restituzione del risultato

- TIPO del valore RESTITUITO come risultato della funzione - Nelle funzioni C viene sempre restituito un solo risultato

- TIPI e NOMI dei PARAMETRI FORMALI: i parametri formali sono usati

nella definizione della funzione; sono i simboli usati nel codice e rappresentano i

dati che vengono ricevuti dalla funzione al momento della sua messa in esecuzione

(cioè i parametri attuali "passati" nella chiamata della funzione)

(33)

Chiamata ed Attivazione di funzione – 1/3 –

Un’altra funzione …

int mcd(int n1, int n2) { int risult;

while (n1!=n2) if (n2>n1) n2=n2-n1;

else n1-=n2;

risult = n1;

return risult;

}

#include <stdio.h>

int main() {

int primo, secondo, m;

printf("...numeri... ");

scanf("%d %d", &primo, &secondo);

m = mcd(primo, secondo);

printf("mcd=%d\n", m);

return 0;

}

(34)

Chiamata ed Attivazione di funzione – 2/3 –

Un’altra funzione …

int mcd(int n1, int n2) { int risult;

while (n1!=n2)

if (n2>n1)n2=n2-n;

else n1-=n2;

risult = n1;

return risult;

}

#include <stdio.h>

int main() {

int primo, secondo, m;

printf("...numeri... ");

scanf("%d %d", &primo, &secondo);

m = mcd(primo, secondo);

printf("mcd=%d\n", m);

return 0;

}

funzione mcd,

PARAMETRI FORMALI: n1, n2 VARIABILI LOCALI: risult

VALORE RISULTATO di tipo int

CHIAMATA di funzione,

(35)

Chiamata ed Attivazione di funzione – 2/3 –

Un’altra funzione …

int mcd(int n1, int n2) { int risult;

while (n1!=n2)

if (n2>n1)n2=n2-n;

else n1-=n2;

risult = n1;

return risult;

}

funzione mcd,

PARAMETRI FORMALI: n1, n2 VARIABILI LOCALI: risult VALORE RISULTATO di tipo int

CHIAMATA di funzione,

- PARAMETRI ATTUALI: primo, secondo

- esecuzione della FUNZIONE CHIAMANTE:

SOSPESA

...

#include <stdio.h>

int main() {

int primo, secondo, m;

printf("...numeri... ");

scanf("%d %d", &primo, &secondo);

m = mcd(primo, secondo);

printf("mcd=%d\n", m);

return 0;

}

(36)

Chiamata ed Attivazione di funzione – 2/3 –

Un’altra funzione …

int mcd(int n1, int n2) { int risult;

while (n1!=n2)

if (n2>n1)n2=n2-n;

else n1-=n2;

risult = n1;

return risult;

}

funzione mcd,

PARAMETRI FORMALI: n1, n2 VARIABILI LOCALI: risult VALORE RISULTATO di tipo int

CHIAMATA di funzione,

- PARAMETRI ATTUALI: primo, secondo

- esecuzione della FUNZIONE CHIAMANTE: SOSPESA

ATTIVAZIONE della FUNZIONE CHIAMATA - passaggio dei parametri:

ATTUALI --> FORMALI

- esecuzione del codice della funzione - terminazione della funzione chiamata

− "restituzione" del risultato nel punto della chiamata

− ripresa dell'esecuzione della funzione chiamante

#include <stdio.h>

int main() {

int primo, secondo, m;

printf("...numeri... ");

scanf("%d %d", &primo, &secondo);

m = mcd(primo, secondo);

printf("mcd=%d\n", m);

return 0;

}

(37)

Chiamata ed Attivazione di funzione – 3/3 –

MEMORIA

#include <stdio.h>

int main() {

int primo, secondo;

...

printf("mcd=%d\n", mcd(primo, secondo));

return 0; }

primo

5

secondo

6

int mcd(int n1, int n2) { int risult;

...

return risult; }

Record di Attivazione

^:

area di memoria riservata per l'esecuzione di una chiamata

RDA

mcd(primo, secondo)

risult

AREA PARAMETRI

AREA VAR LOCALI

n1

n2

... ALTRE AREE

(codice, punto di ritorno)

CHIAMATA di funzione,

- PARAMETRI ATTUALI: primo, secondo

- esecuzione della FUNZIONE CHIAMANTE: SOSPESA

ATTIVAZIONE della FUNZIONE CHIAMATA

1) Allocazione RDA, in cui parametri FORMALI e variabili locali hanno locazioni dedicate 2)

3)

4)

(38)

Chiamata ed Attivazione di funzione – 3/3 –

MEMORIA

#include <stdio.h>

int main() {

int primo, secondo;

...

printf("mcd=%d\n", mcd(primo, secondo));

return 0; }

primo

5

secondo

6

...

Record di Attivazione

^:

RDA

mcd(primo, secondo)

risult

AREA PARAMETRI

AREA VAR LOCALI

n1

n2

... ALTRE AREE

1) Allocazione RDA, in cui parametri FORMALI e variabili locali hanno locazioni dedicate

2) passaggio dei parametri: i valori dei parametri ATTUALI sono copiati nei parametri FORMALI

RISULTATO

(39)

Chiamata ed Attivazione di funzione – 3/3 –

MEMORIA

#include <stdio.h>

int main() {

int primo, secondo;

...

printf("mcd=%d\n", mcd(primo, secondo));

return 0; }

primo

5

secondo

6

...

Record di Attivazione

^:

RDA

mcd(primo, secondo)

risult

AREA PARAMETRI

AREA VAR LOCALI

n1

n2

... ALTRE AREE

6 5

RISULTATO

(40)

Chiamata ed Attivazione di funzione – 3/3 –

MEMORIA

#include <stdio.h>

int main() {

int primo, secondo;

...

printf("mcd=%d\n", mcd(primo, secondo));

return 0; }

primo

5

secondo

6

...

Record di Attivazione

^:

RDA

mcd(primo, secondo)

risult

1 AREA PARAMETRI

AREA VAR LOCALI

n1

n2

... ALTRE AREE

6 5

3) esecuzione del codice della funzione nel RDA (usa solo parametri formali e variabili locali) 4)

RISULTATO

(41)

Chiamata ed Attivazione di funzione – 3/3 –

MEMORIA

#include <stdio.h>

int main() {

int primo, secondo;

...

printf("mcd=%d\n", mcd(primo, secondo));

return 0; }

primo

5

secondo

6

...

Record di Attivazione

^:

RDA

mcd(primo, secondo)

risult

1 AREA PARAMETRI

AREA VAR LOCALI

n1

n2

... ALTRE AREE

6 5

3) esecuzione del codice della funzione nel RDA (usa solo parametri formali e variabili locali) 4) terminazione della funzione chiamata

− restituzione del risultato

− deallocazione RDA

− ripresa della funzione chiamante

RISULTATO

(42)

Chiamata ed Attivazione di funzione – 3/3 –

MEMORIA

#include <stdio.h>

int main() {

int primo, secondo;

...

printf("mcd=%d\n", mcd(primo, secondo));

return 0; }

primo

5

secondo

6

...

return risult; } CHIAMATA di funzione,

3) esecuzione del codice della funzione nel RDA (usa solo parametri formali e variabili locali) 4) terminazione della funzione chiamata

− restituzione del risultato

− deallocazione RDA

− ripresa della funzione chiamante

RDA deallocato … Non c’e’ piu’

Non ci sono piu’ le locazioni dedicate a n1, n2, risult …

(43)

controlli sulle chiamate di funzione

Il compilatore determina se una chiamata e' legittima, in base - al fatto di conoscere la funzione (aver visto definizione)

- e ai tipi di dati coinvolti nell'istruzione in cui appare la chiamata

#include <stdio.h>

int mcdFun (int n1, int n2) { while (n1 != n2)

if (n2>n1) n2=n2-n1;

else n1-=n2;

return(n1);

}

int main () { int n, m, mcd;

printf("fornire i due numeri: ");

scanf("%d %d", &n, &m);

mcd = mcdFun(n,m);

printf("il massimo comun divisore tra %d e %d", n,m);

**printf(" e' %d\n", mcd); /* prosecuzione output */**

…

(44)

controlli sulle chiamate di funzione

Il compilatore determina se una chiamata e' legittima, in base - al fatto di conoscere la funzione

- e ai tipi di dati coinvolti nell'istruzione in cui appare la chiamata

#include <stdio.h>

int mcdFun (int n1, int n2) { while (n1 != n2)

if (n2>n1) n2=n2-n1;

else n1-=n2;

return(n1);

}

int main () { int n, m, mcd;

printf("fornire i due numeri: ");

scanf("%d %d", &n, &m);

mcd = mcdFun(n,m);

printf("il massimo comun divisore tra %d e %d", n,m);

**printf(" e' %d\n", mcd); /* prosecuzione output */**

…

CHIAMATA della funzione mcd, che avviene nell'ambito di una istruzione di assegnazione presente nel programma;

Quando il programma viene compilato, la legittimita' delle istruzioni viene controllata; in particolare viene controllata la legittimaita' di questa chiamata:

a "tempo di compilazione" il Compilatore

- conosce la funzione mcdFun: sa che si chiama mcdFun, che restituisce un valore intero e che riceve due valori interi (quando il compilatore arriva qui ha gia’ visto la definizione della funzione … ci e' gia' "passato sopra …

infatti sta piu' su nel file …)

- controlla la chiamata e decide che

- la chiamata di mcdFun(n,m) e' corretta (ha parametri attuali del numero e tipo giusto)

- il risultato della chiamata e' del tipo giusto per l'uso che se ne vuol fare nell'istruzione di assegnazione

Quindi la chiamata e' legittima

(45)

controlli sulle chiamate di funzione - 2

Il compilatore determina se una chiamata e' legittima, in base - al fatto di conoscere la funzione

- e ai tipi di dati coinvolti nell'istruzione in cui appare la chiamata

#include <stdio.h>

int mcdFun (int n1, int n2) { while (n1 != n2)

if (n2>n1) n2=n2-n1;

else n1-=n2;

return(n1);

}

int main () { int n, m, mcd, p;

printf("fornire i due numeri: ");

scanf("%d %d", &n, &m);

… mcdFun(n); /*  **^*/**

… mcdFn(n,m); /*  **^*/**

… mcdFun(n, m, p); /*  **^*/**

(46)

controlli sulle chiamate di funzione - 2

Il compilatore determina se una chiamata e' legittima, in base - al fatto di conoscere la funzione

- e ai tipi di dati coinvolti nell'istruzione in cui appare la chiamata

#include <stdio.h>

int mcdFun (int n1, int n2) { while (n1 != n2)

if (n2>n1) n2=n2-n1;

else n1-=n2;

return(n1);

}

int main () { int n, m, mcd, p;

printf("fornire i due numeri: ");

scanf("%d %d", &n, &m);

… mcdFun(n); **/* non corretta (too few parameters) */**

… mcdFn(n,m); **/* linker error (funzione non nota) */**

… mcdFun(n, m, p); **/* non corretta (too many …)*/**

(47)

controlli sulle chiamate di funzione - 3

#include <stdio.h>

int main () {

double num, cub;

printf("Gentile utente, dammi un numero …: ");

scanf("%lf", &num);

cub = cube(num);

printf("voila' ... %g\n", cub);

printf("FINE\n");

return 0;

}

double cube (double d) { double ris;

**ris = ddd;**

return(ris);

}

PROVARE QUESTO

PROGRAMMA …. CHE

ERRORI DA’???

(48)

controlli sulle chiamate di funzione - 3

#include <stdio.h>

int main () { double num, cub;

printf("Gentile utente, dammi un numero …: ");

scanf("%lf", &num);

cub = cube(num);

printf("voila' ... %g\n", cub);

printf("FINE\n");

return 0;

}

double cube (double d) { double ris;

**ris = ddd;**

return(ris);

}

Qui c'e' l'inizio del problema:

cube non e' nota al compilatore al momento della chiamata;

e' un errore cui il compilatore tenta di porre rimedio: i tipi coinvolti vengono assunti (per convenzione) tutti come int.

Qui c'e' l'altro estremo del problema: per quel che sa il compilatore la funzione e' int cube(int par)

quindi questa definizione e' sorprendente e provoca un errore di compilazione

MORALE: le funzioni vanno definite, o

dichiarate, prima che qualche altra funzione le chiami.

(49)

definizione Vs. DICHIARAZIONE di funzione

#include <stdio.h>

double cube (double );

int main () { double num, cub;

printf("Gentile utente, dammi un numero …: ");

scanf("%lf", &num);

cub = cube(num);

printf("voila' ... %g\n", cub);

printf("FINE\n");

return 0;

}

**/* DEFINIZIONE di cube()*/**

double cube (double d) { double ris;

**ris = ddd;**

return(ris);

}

Questa e' una dichiarazione della funzione cube;

dichiara, per il compilatore, qual'e' la intestazione della

funzione, cosi' i tipi del risultato e dei parametri sono noti al compilatore, prima che la funzione cube venga usata/chiamata

nella dichiarazione servono - nome della funzione - tipo del risultato - tipi dei parametri

i nomi dei parametri non sono necessari nella dichiarazione (ma si possono mettere se si vuole, tanto il compilatore non sa che farsene)

double cube (double d) double cube (double pippo) (I nomi dei parametri sono evidentemente necessari nella

DEFINIZIONE

⁾

(50)