1 1

Le fun:ioni Le fun:ioni
2 2
Funzioni Funzioni di di libreria libreria
l linguaggio C ha il concetto di funzione. Molte funzioni l linguaggio C ha il concetto di funzione. Molte funzioni
utili sono gi predefinite. utili sono gi predefinite.
Ad esempio, includendo Ad esempio, includendo #include #include< <math.h math.h> >si si
possono usare possono usare sin sin (seno), (seno), cos cos (coseno), (coseno), sqrt sqrt (radice (radice
quadrata), quadrata), ecc ecc. .
#include #include < <stdio.h stdio.h> >
#include #include < <math.h math.h> >
main main() ()
{ { float float a, b, c; a, b, c;
scanf scanf(" ("%f %f %f %f", ",&a &a, , &b &b); );
c = c = sqrt sqrt(a*a+b*b); (a*a+b*b);
printf printf("la diagonale e` ("la diagonale e` %f %f", c); ", c);
} }
a
b
c

Funzioni Funzioni di di libreria libreria
e funzioni si usano all'interno delle e funzioni si usano all'interno delle
espressioni, come gli operatori del espressioni, come gli operatori del
linguaggio C (come linguaggio C (come + +, , - -, , * *, ...) , ...)
c = c = sqrt sqrt(a*a+b*b); (a*a+b*b);
invocazione della funzione: invocazione della funzione:
nome della funzione nome della funzione: : sqrt sqrt
parametri attuali parametri attuali: possono essere: : possono essere:
costanti: costanti: = = sqrt sqrt( (2 2); );
variabili: variabili: = = sqrt sqrt( (y y); );
espressioni: espressioni: = = sqrt sqrt( (3*y+1 3*y+1) ); ;

sempio sempio
ati due numeri a e b, si calcoli ati due numeri a e b, si calcoli a a
b b
e e b b
a a
copiu
incoIIu
p1=1; p1=1;
for (i=0;i<b;i++) for (i=0;i<b;i++)
p1=p1*a; p1=p1*a;
main() main()
{ { int int a, b, a, b, i i, p1; , p1;
scanf("%d % scanf("%d %d",&a,&b d",&a,&b); );
p1=1; p1=1;
for ( for (i i=0;i< =0;i<b;i b;i++) ++)
p1=p1*a; p1=p1*a;

sempio sempio
ati due numeri a e b, si calcoli ati due numeri a e b, si calcoli a a
b b
e e b b
a a
main main() ()
{ { int int a, b, i, p1 a, b, i, p1, p2 , p2; ;
scanf(" scanf("%d %d %d %d", ",&a &a, ,&b &b); );
p1=1; p1=1;
for for (i=0;i<b;i++) (i=0;i<b;i++)
p1=p1*a; p1=p1*a;
p2 p2=1; =1;
for for (i=0;i< (i=0;i<a a;i++) ;i++)
p2 p2= =p2 p2* *b b; ;
odificu u
muno deIIe
differenze
printf(" printf("%d %d %d %d",p1,p2);} ",p1,p2);}

Meglio con le funzioni Meglio con le funzioni
int int power power(int a, int b) (int a, int b)
{ { int i,p=1; int i,p=1;
for for (i=0;i<b;i++) (i=0;i<b;i++)
p = p = p*a p*a; ;
return return p; p;
} }
main main() ()
{ { int a,b; int a,b;
scanf(" scanf("%d %d %d %d", ",&a &a, ,&b &b); );
printf(" printf("%d %d %d %d", ",power power(a,b), (a,b),power power(b,a)); (b,a));
} }
defini;ione
invoco;ioni

l linguaggio C realizza solo il concetto di funzione.
SOTTOPROGRAMMI SOTTOPROGRAMMI
n sottoprogramma una nuova istruzione, o n sottoprogramma una nuova istruzione, o
un nuovo operatore definito dal programmatore un nuovo operatore definito dal programmatore
per sintetizzare una sequenza di istruzioni. per sintetizzare una sequenza di istruzioni.
n particolare: n particolare:
ocedua ocedua: un sottoprogramma che rappresenta : un sottoprogramma che rappresenta
un' un'istruzione istruzione non primitiva non primitiva
funzione funzione: un sottoprogramma che rappresenta un : un sottoprogramma che rappresenta un
operatore operatore non primitivo. non primitivo.
Tutti i linguaggi di alto livello offrono la Tutti i linguaggi di alto livello offrono la
possibilit di definire funzioni e/o procedure. possibilit di definire funzioni e/o procedure.
8 8
OO na na unzione unzione un un componente sotware componente sotware
che cattura l'idea matematica di funzione che cattura l'idea matematica di funzione
OO molti possibili ingressi molti possibili ingressi
(che non vengono modificati!) (che non vengono modificati!)
OO una sola uscita una sola uscita (il risultato) (il risultato)
na funzione na funzione
riceve dati di ingresso riceve dati di ingresso in corrispondenza ai in corrispondenza ai
parametri parametri
ha come corpo una ha come corpo una espressione espressione, la cui , la cui
valutazione fornisce un risultato valutazione fornisce un risultato
denota un valore denota un valore in corrispondenza al suo in corrispondenza al suo
nome nome
IOI COME COMPOETI SW IOI COME COMPOETI SW
unzione
risultato
parametro1
parametro2
parametro n

< <definizione definizione- -di di- -funzione funzione> ::= > ::=
< <tipoValore tipoValore> ><nome>( <nome>(<parametri <parametri- -formali> formali>) )
{ {
<corpo> <corpo>
} }
<parametri <parametri- -formali> formali>
o una o una lista vuota lista vuota: : oid oid
o una o una lista di variabili lista di variabili (separate da virgole) (separate da virgole) isibili solo isibili solo
entro il corpo della unzione. entro il corpo della unzione.
< <tipoValore tipoValore> >
deve coincidere con il tipo del valore risultato della funzione deve coincidere con il tipo del valore risultato della funzione
EIIIOE EIIIOE I I IOE IOE
10 10
< <definizione definizione- -di di- -funzione funzione> ::= > ::=
< <tipoValore tipoValore> ><nome>( <nome>(<parametri <parametri- -formali> formali>) )
{ {
<corpo> <corpo>
} }
ella ella parte parte orpo orpo possono possono essere essere presenti presenti definizioni definizioni
e/o e/o dichiarazioni dichiarazioni locali locali ( (ae ae dichiaazioni dichiaazioni) ) e e un un
insieme insieme di di istruzioni istruzioni ( (ae ae isuzioni isuzioni) )..
dati dati riferiti riferiti nel nel corpo corpo possono possono essere essere ostanti ostanti,, variabili variabili,,
oppure oppure parametri parametri formali formali..
All'interno All'interno del del corpo, corpo, i i parametri parametri formali formali vengono vengono trattati trattati
come come variabili variabili..
EIIIOE EIIIOE I I IOE IOE
11 11
OO 'istruzione 'istruzione return return serve a fornire al cliente il valore serve a fornire al cliente il valore
di ritorno di ritorno
return return <espressione> <espressione>; ;
OO rovoca la restituzione del controllo al cliente, rovoca la restituzione del controllo al cliente,
unitamente al valore dell'espressione che la segue. unitamente al valore dell'espressione che la segue.
OO ventuali istruzioni successive alla ventuali istruzioni successive alla return return non non
saranno mai eseguite! saranno mai eseguite!
RISTATO RISTATO I I A IOE A IOE
12 12
int int power power(int a, int b) (int a, int b)
{ { int i,p=1; int i,p=1;
for for (i=0;i<b;i++) (i=0;i<b;i++)
p = p = p*a p*a; ;
return return p; p;
} }
OO l simbolo l simbolo power power denota il nome della funzione denota il nome della funzione
OO e variabili intere e variabili intere a a e e b b sono i parametri (formali) della sono i parametri (formali) della
funzione funzione
OO l valore restituito un intero l valore restituito un intero int int..
ESEMPIO ESEMPIO
interfucciu
1 1
a chiamata a chiamata (o (o invocazione invocazione) ) di funzione di funzione
un'espressione un'espressione della forma della forma
< <nomefunzione nomefunzione> > ( ( <parametri <parametri- -attuali> attuali> ) )
dove: dove:
<parametri <parametri- -attuali> ::= attuali> ::=
[ <espressione> ] { [ <espressione> ] { , , < <espressione espressione> } > }
parametri attuali devono corrispondere ai parametri attuali devono corrispondere ai
parametri formali parametri formali
Come numero Come numero
Come tipo Come tipo
CHIAMATA CHIAMATA I I IOE IOE
1 1
nvocazione delle funzioni nvocazione delle funzioni
na volta definita una funzione, la posso na volta definita una funzione, la posso
invocare pi volte, anche all'interno delle invocare pi volte, anche all'interno delle
espressioni espressioni
main main() ()
{ { int a,b,c,Delta; int a,b,c,Delta;
scanf(" scanf("%d %d %d %d %d %d", ",&a &a, ,&b &b, ,&c &c); );
Delta = Delta = power power(b,2) (b,2)- -4*a*c; 4*a*c;
printf(" printf("%d %d",Delta); ",Delta);
} }
tutti gli eetti,
power un nuoo
operatore che
posso usare nel
programma!
tutti gli eetti,
power un nuoo
operatore che
posso usare nel
programma!
1 1
sercizio sercizio
Si leggano da tastiera due numeri interi Si leggano da tastiera due numeri interi a a
e e b b, controllando che siano entrambi , controllando che siano entrambi
compresi fra 0 e 10. compresi fra 0 e 10.
Se l'utente inserisce un valore esterno Se l'utente inserisce un valore esterno
all'intervallo 0 all'intervallo 0- -10 si mostri un messaggio 10 si mostri un messaggio
di errore e si faccia inserire nuovamente di errore e si faccia inserire nuovamente
il numero il numero
Si stampi poi il maggiore dei due Si stampi poi il maggiore dei due
1 1
antaggi antaggi
Scrivo il codice una volta sola Scrivo il codice una volta sola
l codice pi chiaro: l codice pi chiaro:
Se do nomi significativi alle funzioni, Se do nomi significativi alle funzioni,
spiegano gi che cosa fanno, ho meno spiegano gi che cosa fanno, ho meno
bisogno di commenti, spiegazioni, . bisogno di commenti, spiegazioni, .
1 1
nformation hiding nformation hiding
int int power power( (int int a, a, int int b) b)
{ { int int i,p=1; i,p=1;
for for (i=0;i<b;i++) (i=0;i<b;i++)
p = p = p*a p*a; ;
return return p; p;
} }
main main() ()
{ { int int =3,y=2,i; =3,y=2,i;
i = i = power power(,y); (,y);
} }
l l main main ( (e le altre funzioni e le altre funzioni) )
non possono modificare il non possono modificare il
valore delle variabili locali valore delle variabili locali
questo permette di questo permette di
scrivere il scrivere il main main
disinteressandosi da disinteressandosi da
come realizzata la come realizzata la
funzione funzione power power
Queste due variabili si
chiamano entrambe i,
ma sono variabili diverse
18 18
nformation hiding nformation hiding
oich ogni funzione pu modificare solo oich ogni funzione pu modificare solo
le sue variabili, posso modificare ogni le sue variabili, posso modificare ogni
funzione indipendentemente funzione indipendentemente
correggere errori correggere errori
aggiungere funzionalit aggiungere funzionalit
usare algoritmi pi efficienti usare algoritmi pi efficienti
evo solo stare attento a non modificare evo solo stare attento a non modificare
l'interfaccia l'interfaccia
'interfaccia contiene tutte le informazioni 'interfaccia contiene tutte le informazioni
che servono a chi vuole invocare la che servono a chi vuole invocare la
funzione funzione
1 1
sercizio sercizio
ati due numeri a e b, si calcoli ati due numeri a e b, si calcoli a a
b b
e e b b
a a
Si modifichi ora il programma in modo che funzioni anche Si modifichi ora il programma in modo che funzioni anche
con esponenti negativi con esponenti negativi
float float power power(int a, int b) (int a, int b)
{ { int i; int i;
float float p=1; p=1;
if if (b>=0) (b>=0)
for for (i=0; i<b; i++) (i=0; i<b; i++)
p = p = p*a p*a; ;
else else
for for (i=0; i< (i=0; i< - -b; i++) b; i++)
p = p = p p/a; /a;
return return p; p;
} }
main main() ()
{ { int a,b; int a,b;
scanf(" scanf("%d %d %d %d", ",&a &a, ,&b &b); );
printf(" printf("%f %f ", ",power power(a,b)); (a,b));
printf(" printf("%f %f ", ",power power(b,a)); (b,a));
} }
20 20
antaggi antaggi
Se devo effettuare una Se devo effettuare una modifica modifica, la faccio in un , la faccio in un
solo punto solo punto
s s: se voglio considerare anche potenze negative? : se voglio considerare anche potenze negative?
se trovo un algoritmo pi efficiente? se trovo un algoritmo pi efficiente?
se trovo un errore nell'algoritmo? se trovo un errore nell'algoritmo?
on devo modificare il on devo modificare il main main, a meno che , a meno che
non cambi l'interfaccia della funzione non cambi l'interfaccia della funzione
21 21
antaggi antaggi
Riutilizzo Riutilizzo del codice del codice
Se voglio utilizzare la funzione potenza, posso fare un copia Se voglio utilizzare la funzione potenza, posso fare un copia- -
incolla in un altro programma (senza dovermi preoccupare di incolla in un altro programma (senza dovermi preoccupare di
cambiare i nomi delle variabili, .) cambiare i nomi delle variabili, .)
osso dare il mio codice ad altri, o usare il codice fatto da altri, osso dare il mio codice ad altri, o usare il codice fatto da altri,
senza dover guardare l'algoritmo, controllare che non ci siano senza dover guardare l'algoritmo, controllare che non ci siano
conflitti con i nomi delle variabili, . conflitti con i nomi delle variabili, .
l codice che ho scritto e testato in un'altra applicazione l codice che ho scritto e testato in un'altra applicazione
probabilmente corretto probabilmente corretto
Suddivisione del lavoro: varie persone possono Suddivisione del lavoro: varie persone possono
collaborare indipendentemente, mettendosi d'accordo collaborare indipendentemente, mettendosi d'accordo
sulle interfacce sulle interfacce
tilizzo meno memoria (il sorgente pi corto, ed tilizzo meno memoria (il sorgente pi corto, ed
anche il compilato) anche il compilato)
22 22
sercizio sercizio
Si scriva una funzione che verifica se un Si scriva una funzione che verifica se un
anno bisestile anno bisestile
Si legga poi da tastiera una Si legga poi da tastiera una
data e si dica se valida data e si dica se valida
2 2
sempio sempio
int int power power( (int int a, a, int int b) b)
{ { int int i,p=1; i,p=1;
for for (i=0;i<b;i++) (i=0;i<b;i++)
p = p = p*a p*a; ;
return return p; p;
} }
main main() ()
{ { int int =3,y=2,k,j; =3,y=2,k,j;
k = k = power power(,y); (,y);
j = j = power power(y,+1); (y,+1);
} }
2 2
Modello Cliente Modello Cliente- -Servitore Servitore
l meccanismo di uso di funzioni nei linguaggi di programmazione fa l meccanismo di uso di funzioni nei linguaggi di programmazione fa
riferimento allo schema di interazione tra componenti software riferimento allo schema di interazione tra componenti software
cIiene cIiene - - seioe seioe
( (client client serer serer) )
s: segreteria studenti s: segreteria studenti
o studente fornisce alla persona allo sportello: o studente fornisce alla persona allo sportello:
domanda di iscrizione domanda di iscrizione
fototessera fototessera
la carta d'identit la carta d'identit
il certificato di maturit il certificato di maturit
bollettino pagamento tasse bollettino pagamento tasse
a persona allo sportello fornisce a persona allo sportello fornisce
libretto libretto
nome utente/password per la posta elettronica nome utente/password per la posta elettronica
o studente o studente si disinteressa completamente si disinteressa completamente di che cosa viene effettuato di che cosa viene effettuato
dalla segreteria; gli interessa solo sapere come accedere al servizio: dalla segreteria; gli interessa solo sapere come accedere al servizio:
qual lo sportello giusto qual lo sportello giusto
quali informazioni deve fornire alla segreteria quali informazioni deve fornire alla segreteria
quali informazioni gli vengono date in cambio quali informazioni gli vengono date in cambio
2 2
interaccia interaccia (o firma o (o firma o
signature signature) di una funzione ) di una funzione
comprende comprende
nome della unzione nome della unzione
lista dei parametri lista dei parametri
tipo del alore da essa tipo del alore da essa
denotato denotato
ITERACCIA I A IOE ITERACCIA I A IOE
cIiene seioe
Chiamaa deIIa funzione
con i aamei ichiesi
VaIoe esiuio
daIIa funzione
splicita il contratto di servizio splicita il contratto di servizio ra cliente e seritore. ra cliente e seritore.
Cliente e seritore comunicano quindi mediante Cliente e seritore comunicano quindi mediante
i i parametri parametri trasmessi dal cliente al seritore allatto della chiamata trasmessi dal cliente al seritore allatto della chiamata
(direzione: dal cliente al seritore) (direzione: dal cliente al seritore)
il il valore restituito valore restituito dal seritore al cliente direzione: dal seritore al dal seritore al cliente direzione: dal seritore al
cliente) cliente)
2 2
SM SM
Calcolo del massimo di Calcolo del massimo di
due valori due valori
Sequenza operazioni: Sequenza operazioni:
l cliente comunica al l cliente comunica al
servitore i due valori servitore i due valori
l servitore calcola il massimo l servitore calcola il massimo
l servitore comunica al l servitore comunica al
cliente il valore del massimo cliente il valore del massimo
cIiene max
3, 5
5
Cliente e seritore deono essere daccordo su:
il tipo dei alori int
quanti sono i alori 2
qual il nome del seritore max
qual il tipo del alore di ritorno int
l cliente non interessato allalgoritmo che il seritore
utilizza
2 2

Quindi, dal lato del servitore Quindi, dal lato del servitore
dovr esserci scritto: dovr esserci scritto:
come si chiama come si chiama
di quanti dati ha bisogno e di di quanti dati ha bisogno e di
che tipo che tipo
di che tipo il valore di che tipo il valore
calcolato calcolato
l cliente dovr l cliente dovr
mandare al servitore mandare al servitore
identificato da quel identificato da quel
nome nome
i dati di ingresso, in i dati di ingresso, in
numero e tipo giusti numero e tipo giusti
ricevere il risultato ricevere il risultato
cliente
max(3,5)
nteraccia
nome: max
input: int x
int y
output: int
algoritmo
seritore 3 5
5
28 28
COMICAIOE CIETE COMICAIOE CIETE SERVITORE SERVITORE
arametri arametri ormali ormali ::
sono specificati nella sono specificati nella
dichiarazione dichiarazione del servitore del servitore
esplicitano esplicitano il contratto il contratto fra fra
servitore e cliente servitore e cliente
indicano indicano cosa il seritore cosa il seritore
si aspetta dal cliente si aspetta dal cliente
arametri arametri attuali attuali ::
sono sono trasmessi dal cliente trasmessi dal cliente
all'atto della chiamata all'atto della chiamata
devono corrispondere ai devono corrispondere ai
parametri formali parametri formali
in in numero numero, , posizione posizione e e
tipo tipo
cliente
max(3,5)
nteraccia
nome: max
input: int x
int y
output: int
algoritmo
seritore
l cliente passa inormazioni al seritore tramite una serie di
aamei
2 2
int int ma ma (int (int , int , int y y ){ ){
if (>y) return ; if (>y) return ;
else return y; else return y;
} }
ESEMPIO ESEMPIO
VITO
definizione
della
funzione
main(){
int z = 8;
int m;
m = ma(z , 4);
}
Parametri Formali
CLIT
chiamata
della
funzione
Parametri Attuali
0 0
egame tra parametri attuali e parametri egame tra parametri attuali e parametri
formali: effettuato formali: effettuato al momento della al momento della
chiamata chiamata, in modo dinamico. , in modo dinamico.
Tale legame: Tale legame:
vale solo per l'invocazione corrente vale solo per l'invocazione corrente
vale solo per la durata della funzione. vale solo per la durata della funzione.
COMICAIOE CIETE/SERVITORE COMICAIOE CIETE/SERVITORE
1 1
int int ma ma (int (int , , int int y y ){ ){
if (>y) return ; if (>y) return ;
else return y; else return y;
} }
ESEMPIO ESEMPIO
main(){
int z = 8;
int m1,m2;
m1 = ma(z,4);
m2 = ma(5,z);
}
Parametri Formali
All'atto di questa
chiamata della
funzione si
effettua un legame
tra
e z
y e 4
2 2
int int ma ma (int (int , int , int y y ){ ){
if (>y) return ; if (>y) return ;
else return y; else return y;
} }
ESEMPIO ESEMPIO
main(){
int z = 8;
int m1,m2;
m1 = ma(z,4);
m2 = ma(5,z);
}
Parametri Formali
All'atto di questa
chiamata della
funzione si
effettua un legame
tra
e 5
y e z

a a struttura interna struttura interna (corpo) di una funzione (corpo) di una funzione
completamente inaccessibile dallesterno. completamente inaccessibile dallesterno.
Cos facendo si garantisce Cos facendo si garantisce protezione protezione
dellinormazione dellinormazione ( (inormation inormation hiding hiding) )
na funzione accessibile S attraverso la na funzione accessibile S attraverso la
sua interfaccia. sua interfaccia.
Quindi posso cambiare l'algoritmo della Quindi posso cambiare l'algoritmo della
funzione senza preoccuparmi di quello che funzione senza preoccuparmi di quello che
succede dal lato del cliente succede dal lato del cliente
IORMATIO HIIG IORMATIO HIIG

sercizio sercizio
Scrivere una funzione che prende in Scrivere una funzione che prende in
ingresso due strutture di tipo ingresso due strutture di tipo punto punto
typedef struct typedef struct
{ int ,y;} punto; { int ,y;} punto;
e calcola la distanza di e calcola la distanza di Manhattan Manhattan fra i fra i
due punti due punti

sercizio sercizio (adattato dal compito (adattato dal compito gen gen 0) 0)
Sia data la definizione Sia data la definizione
typedef typedef struct struct { {int int ,y; } punto; ,y; } punto;
Si definisca una struttura che rappresenta una Si definisca una struttura che rappresenta una
figura geometrica. a struttura contiene: figura geometrica. a struttura contiene:
Tipo Tipo: stringa che pu essere "CRCH o "QARAT : stringa che pu essere "CRCH o "QARAT
: punto che rappresenta : punto che rappresenta
il centro, nel caso del cerchio il centro, nel caso del cerchio
il punto in basso a sinistra, nel caso del quadrato il punto in basso a sinistra, nel caso del quadrato
: lunghezza : lunghezza
del raggio, nel caso del cerchio del raggio, nel caso del cerchio
del lato, nel caso del quadrato del lato, nel caso del quadrato
Si scriva una funzione che prende in ingresso una Si scriva una funzione che prende in ingresso una
struttura struttura figura figura e un punto e fornisce e un punto e fornisce
1 se il punto interno alla figura 1 se il punto interno alla figura
0 se il punto esterno 0 se il punto esterno

Modello Modello a run a run- -time time delle delle funzioni funzioni
er eseguire una funzione bisogna: er eseguire una funzione bisogna:
1. 1. creare le variabili creare le variabili
2. 2. ricopiare il valore dei parametri ricopiare il valore dei parametri
. . eseguire il codice della funzione eseguire il codice della funzione
. . restituire il risultato restituire il risultato
. . liberare l'area di memoria che conteneva le liberare l'area di memoria che conteneva le
variabili variabili
n particolare, le variabili che erano definite n particolare, le variabili che erano definite
all'interno della funzione hanno, come all'interno della funzione hanno, come tempo di tempo di
vita vita, quello in cui esiste la funzione, da quando , quello in cui esiste la funzione, da quando
viene invocata a quando esegue l'istruzione viene invocata a quando esegue l'istruzione
return return..

Creazione Creazione delle delle variabili variabili
e e variabili variabili necessarie necessarie all'esecuzione all'esecuzione
della della funzione funzione sono sono
i i parametri parametri
le le variabili variabili locali locali
Queste Queste vengono vengono inserite inserite in in una una struttura struttura
dati dati detta detta record record di di attivazione attivazione della della
funzione funzione
8 8
All'atto della chiamata, All'atto della chiamata, I'esecuzione deI cIiene iene I'esecuzione deI cIiene iene
sosesa sosesa e e iI conoIIo assa aI seioe iI conoIIo assa aI seioe..
l servitore "vive solo per il tempo necessario a svolgere l servitore "vive solo per il tempo necessario a svolgere
il servizio. il servizio.
Al termine, il servitore "muore, e Al termine, il servitore "muore, e lesecuzione torna al lesecuzione torna al
cliente. cliente.
n particolare, le variabili che erano definite all'interno n particolare, le variabili che erano definite all'interno
della funzione hanno, come della funzione hanno, come tempo di vita tempo di vita, quello in cui , quello in cui
esiste la funzione, da quando viene invocata a quando esiste la funzione, da quando viene invocata a quando
esegue l'istruzione esegue l'istruzione return return..
IOI COME COMPOETI SW: IOI COME COMPOETI SW:
CIT E MORTE CIT E MORTE

M A R M A R- -TM TM
el momento in cui una funzione viene el momento in cui una funzione viene
invocata, necessario invocata, necessario creare creare delle nuove delle nuove
variabili variabili
Bisogner richiedere dello spazio in Bisogner richiedere dello spazio in
memoria per allocare memoria per allocare
i parametri formali i parametri formali
le variabili locali le variabili locali
iene creato il iene creato il Reord di Attivazione Reord di Attivazione
della funzione della funzione
0 0
All'atto dell'invocazione di una funzione: All'atto dell'invocazione di una funzione:
si crea una si crea una nuoa attiazione (istanza) nuoa attiazione (istanza)
del seritore del seritore
si alloca la memoria per i parametri si alloca la memoria per i parametri
(e le eventuali variabili locali) (e le eventuali variabili locali)
si trasferiscono i parametri al servitore si trasferiscono i parametri al servitore
si trasferisce il controllo al servitore si trasferisce il controllo al servitore
si esegue il codice della funzione. si esegue il codice della funzione.
RIASSMEO... RIASSMEO...
1 1
il ' il 'mondo deIIa funzione mondo deIIa funzione: : coniene uo coniene uo
ci che ne caaeizza I'esisenza ci che ne caaeizza I'esisenza
i i parametri parametri rievuti rievuti
le le variabili variabili loali loali
l' l'indirizzo di ritorno indirizzo di ritorno Reun Reun addess addess R R che che
indica il punto a cui tornare (nel codice del cliente) indica il punto a cui tornare (nel codice del cliente)
al termine della funzione, per permettere al cliente al termine della funzione, per permettere al cliente
di proseguire una volta che la funzione termina di proseguire una volta che la funzione termina
un un ollegamento al reord di attivazione del ollegamento al reord di attivazione del
liente liente ink Dinamico ink Dinamico D D
RECOR RECOR I I ATTIVAIOE ATTIVAIOE
2 2
Return
address
nk
dnam
mensne del
rerd (nn fssa)
Parametr 1
Parametr 2

arable lale 1
....
arable lale 2
RECOR RECOR I I ATTIVAIOE ATTIVAIOE

sercizio sercizio
Si scriva un programma C che legge da Si scriva un programma C che legge da
tastiera numeri e verifica se questi tastiera numeri e verifica se questi
costituiscono una terna pitagorica. costituiscono una terna pitagorica.
Si supponga che l'utente inserisca i Si supponga che l'utente inserisca i
numeri in ordine dal pi piccolo al pi numeri in ordine dal pi piccolo al pi
grande grande
a
b
c

Rappresenta il " Rappresenta il "mondo della unzione mondo della unzione: : nasce e muore nasce e muore
con essa con essa
creato al momento della invocazione di una funzione creato al momento della invocazione di una funzione
permane per tutto il tempo in cui la funzione in esecuzione permane per tutto il tempo in cui la funzione in esecuzione
distrutto ( distrutto (deallocato deallocato) al termine dell'esecuzione della funzione ) al termine dell'esecuzione della funzione
stessa. stessa.
Ad ogni chiamata di funzione viene Ad ogni chiamata di funzione viene creato un nuoo creato un nuoo
record, speciico per record, speciico per quella quella chiamata di chiamata di quella quella unzione unzione
a dimensione del record di attivazione a dimensione del record di attivazione
varia da una funzione all'altra varia da una funzione all'altra
per una data unzione, issa e calcolabile a priori per una data unzione, issa e calcolabile a priori
RECOR RECOR I I ATTIVAIOE ATTIVAIOE

unzioni che chiamano altre unzioni unzioni che chiamano altre unzioni danno luogo a danno luogo a
una una sequenza sequenza di record di attivazione di record di attivazione
allocati secondo l'ordine delle chiamate allocati secondo l'ordine delle chiamate
deallocati in ordine inverso deallocati in ordine inverso
a sequenza dei link dinamici a sequenza dei link dinamici costituisce la costituisce la
cosiddetta cosiddetta catena dinamica catena dinamica, che rappresenta , che rappresenta la storia la storia
delle attiazioni delle attiazioni
("chi ha chiamato chi) ("chi ha chiamato chi)
RECOR RECOR I I ATTIVAIOE ATTIVAIOE

er catturare la semantica delle chiamate annidate er catturare la semantica delle chiamate annidate
(una funzione che chiama un'altra funzione che...), (una funzione che chiama un'altra funzione che...),
l'area di memoria in cui vengono allocati i record di l'area di memoria in cui vengono allocati i record di
attivazione deve essere gestita attivazione deve essere gestita come una pila come una pila
STACK STACK
na struttura dati gestita con politica F (ast n, na struttura dati gestita con politica F (ast n,
First ut First ut - - l'ultimo a entrare il primo a uscire) l'ultimo a entrare il primo a uscire)
RECOR RECOR I I ATTIVAIOE ATTIVAIOE

ormalmente lo STACK dei record di attivazione si ormalmente lo STACK dei record di attivazione si
disegna nel modo seguente disegna nel modo seguente
Quindi, se la funzione Quindi, se la funzione chiama la funzione chiama la funzione lo lo
stack stack evolve nel modo seguente evolve nel modo seguente
RECOR RECOR I I ATTIVAIOE ATTIVAIOE

poi inisce
e il controllo
torna ad

chiama e
passa il
controllo a
sequenza
attivazioni
8 8
Il valore di ritorno Il valore di ritorno alolato dalla funzione alolato dalla funzione
pu essere pu essere esiuio aI cIiene esiuio aI cIiene in due modi: in due modi:
inserendo un apposito 'slot nel reord di inserendo un apposito 'slot nel reord di
attivazione attivazione
il cliente deve copiarsi il risultato da qualche parte il cliente deve copiarsi il risultato da qualche parte
prima prima che il record venga distrutto che il record venga distrutto
tramite un registro della CP tramite un registro della CP
soluzione pi semplice ed efficiente, privilegiata soluzione pi semplice ed efficiente, privilegiata
ovunque possibile. ovunque possibile.
RECOR RECOR I I ATTIVAIOE ATTIVAIOE

Programma: Programma:
int int ( (int int A) { A) { return return A+1; } A+1; }
int int Q( Q(int int ) { ) { return return (); } (); }
int int P( P(oid oid) { ) { int int a=10; a=10; return return Q(a); } Q(a); }
main main() { () { int int = P(); } = P(); }
Sequenza iamate: Sequenza iamate:
.O. .O. FF main main FF P() P() FF Q() Q() FF () ()
ESEMPIO ESEMPIO I I CHIAMATE AIATE CHIAMATE AIATE
0 0
Sequenza iamate: Sequenza iamate:
.O. .O. FF main main FF P() P() FF Q() Q() FF () ()
sequenza
attivazioni
P
main
Q

ESEMPIO I CHIAMATE AIATE ESEMPIO I CHIAMATE AIATE

1 1
Funzioni e strutture Funzioni e strutture
Con le funzioni si possono usare come Con le funzioni si possono usare come
parametri e come valore di ritorno le strutture parametri e come valore di ritorno le strutture
(con gli array un po' diverso, come vedremo) (con gli array un po' diverso, come vedremo)
'utilizzo delle funzioni permette di costruire 'utilizzo delle funzioni permette di costruire
semplicemente applicazioni con la metodologia semplicemente applicazioni con la metodologia
top top- -down down
Si scriva un programma che permette di Si scriva un programma che permette di
leggere due frazioni leggere due frazioni
calcolarne la somma calcolarne la somma
visualizzare il risultato visualizzare il risultato

2 2
sempio sempio
er prima cosa, definiamo le strutture dati: er prima cosa, definiamo le strutture dati:
una frazione costituita da un numeratore ed un denominatore una frazione costituita da un numeratore ed un denominatore
typedef struct { int num; int den; } frazione; typedef struct { int num; int den; } frazione;
oi scriviamo l'algoritmo partendo dalla versione pi astratta. oi scriviamo l'algoritmo partendo dalla versione pi astratta.
Scriviamo il main invocando le varie funzioni che ci servono Scriviamo il main invocando le varie funzioni che ci servono
main() main()
{ frazione f1, f2, somma; { frazione f1, f2, somma;
f1 = leggiFrazione(); f1 = leggiFrazione();
f2 = leggiFrazione(); f2 = leggiFrazione();
somma = sum(f1,f2); somma = sum(f1,f2);
printf("%d/%d",somma.num,somma.den); printf("%d/%d",somma.num,somma.den);
} }

sempio sempio
oi implementiamo le funzioni che oi implementiamo le funzioni che
abbiamo invocato nel main: abbiamo invocato nel main:
frazione leggiFrazione() frazione leggiFrazione()
{ frazione f; { frazione f;
scanf("%d",&f.num); scanf("%d",&f.num);
scanf("%d",&f.den); scanf("%d",&f.den);
return f; return f;
} }

sempio sempio
a somma di due frazioni si calcola cos: a somma di due frazioni si calcola cos:
calcolo il minimo comun denominatore (minimo comune multiplo dei calcolo il minimo comun denominatore (minimo comune multiplo dei
denominatori); questo il denominatore della somma denominatori); questo il denominatore della somma
porto la prima frazione al comun denominatore porto la prima frazione al comun denominatore
porto la seconda frazione al comun denominatore porto la seconda frazione al comun denominatore
calcolo la somma dei numeratori: questo il numeratore della somma calcolo la somma dei numeratori: questo il numeratore della somma
frazione sum(frazione f1, frazione f2) frazione sum(frazione f1, frazione f2)
{ int mcd; { int mcd; // minimo comun denominatore // minimo comun denominatore
frazione somma; frazione somma;
mcd = mcm(f1.den,f2.den); mcd = mcm(f1.den,f2.den);
somma.den = mcd; somma.den = mcd;
f1 = portaDen(f1,mcd); f1 = portaDen(f1,mcd);
f2 = portaDen(f2,mcd); f2 = portaDen(f2,mcd);
somma.num = f1.num + f2.num; somma.num = f1.num + f2.num;
return somma; return somma;
} }

sempio sempio
nfine implementiamo le funzioni che abbiamo usato nelle funzioni nfine implementiamo le funzioni che abbiamo usato nelle funzioni
er portare una frazione ad un denominatore, devo moltiplicare er portare una frazione ad un denominatore, devo moltiplicare
numeratore e denominatore per la stessa quantit numeratore e denominatore per la stessa quantit
nuovoum/nuovoen = vecchioum/vecchioen nuovoum/nuovoen = vecchioum/vecchioen
quindi quindi
nuovoum=vecchioum*nuovoen/vecchioen nuovoum=vecchioum*nuovoen/vecchioen
frazione portaDen(frazione f, int nDen) frazione portaDen(frazione f, int nDen)
{ frazione nuoo; { frazione nuoo;
nuoo.den = nDen; nuoo.den = nDen;
nuoo.num = f.num*nDen/f.den; nuoo.num = f.num*nDen/f.den;
return nuoo; return nuoo;
} }

sempio sempio
er calcolare il minimo comune multiplo er calcolare il minimo comune multiplo
di due interi, posso farne il prodotto e di due interi, posso farne il prodotto e
dividere per il massimo comun divisore dividere per il massimo comun divisore
dei due dei due
int mcm(int a, int b) int mcm(int a, int b)
{ return a*b/MCD(a,b); { return a*b/MCD(a,b);
} }

sempio sempio
er calcolare il MC di due numeri, posso er calcolare il MC di due numeri, posso
usare il metodo di uclide usare il metodo di uclide
int MCD(int m, int n) int MCD(int m, int n)
{ while (m != n) { while (m != n)
if (m>n) if (m>n)
m=m m=m- -n; n;
else n=n else n=n- -m; m;
return m; return m;
} } 8 8
programma risutante programma risutante
#include <stdio.h> #include <stdio.h>
typedef struct { int num; int den; } typedef struct { int num; int den; }
frazione; frazione;
int MCD(int m, int n) int MCD(int m, int n)
{ while (m != n) { while (m != n)
if (m>n) if (m>n)
m=m m=m- -n; n;
else n=n else n=n- -m; m;
return m; return m;
} }
int mcm(int a, int b) int mcm(int a, int b)
{ return a*b/MCD(a,b); { return a*b/MCD(a,b);
} }
frazione portaDen(frazione f, int frazione portaDen(frazione f, int
nDen) nDen)
{ frazione nuoo; { frazione nuoo;
nuoo.den = nDen; nuoo.den = nDen;
nuoo.num = f.num*nDen/f.den; nuoo.num = f.num*nDen/f.den;
return nuoo; return nuoo;
} }
frazione sum(frazione f1, frazione f2) frazione sum(frazione f1, frazione f2)
{ int mcd; { int mcd;
frazione somma; frazione somma;
mcd = mcm(f1.den,f2.den); mcd = mcm(f1.den,f2.den);
somma.den = mcd; somma.den = mcd;
f1 = portaDen(f1,mcd); f1 = portaDen(f1,mcd);
f2 = portaDen(f2,mcd); f2 = portaDen(f2,mcd);
somma.num = f1.num + f2.num; somma.num = f1.num + f2.num;
return somma; return somma;
} }
frazione leggiFrazione() frazione leggiFrazione()
{ frazione f; { frazione f;
scanf("%d",&f.num); scanf("%d",&f.num);
scanf("%d",&f.den); scanf("%d",&f.den);
return f; return f;
} }
main() main()
{ frazione f1, f2, somma; { frazione f1, f2, somma;
f1 = leggiFrazione(); f1 = leggiFrazione();
f2 = leggiFrazione(); f2 = leggiFrazione();
somma = sum(f1,f2); somma = sum(f1,f2);
printf("%d/%d",somma.num,somma.den); printf("%d/%d",somma.num,somma.den);
} }

l programma risultante l programma risultante
abbastanza facile da scrivere e da capire abbastanza facile da scrivere e da capire
facile da modificare facile da modificare
s: voglio assicurarmi che l'utente non inserisca una frazione che s: voglio assicurarmi che l'utente non inserisca una frazione che
ha per denominatore zero ha per denominatore zero
ntervengo in una sola funzione: la ntervengo in una sola funzione: la leggiFrazione leggiFrazione
una funzione di istruzioni, quindi facile da capire e da modificare una funzione di istruzioni, quindi facile da capire e da modificare
frazione leggiFrazione() frazione leggiFrazione()
{ frazione f; { frazione f;
do do
{ { scanf("%d",&f.num); scanf("%d",&f.num);
scanf("%d",&f.den); scanf("%d",&f.den);
if (f.den==0) if (f.den==0)
printf(e printf(e- -inserire la frazione inserire la frazione\ \n"); n");
} while (f.den == 0); } while (f.den == 0);
return f; return f;
} } 0 0
Modificabilit Modificabilit
ra voglio che mi fornisca solo frazioni ai minimi ra voglio che mi fornisca solo frazioni ai minimi
termini termini
Aggiungo una funzione Aggiungo una funzione riduci riduci. osso invocarla nel . osso invocarla nel
main main
main() main()
{ { frazione f1, f2, somma; frazione f1, f2, somma;
f1 = leggiFrazione(); f1 = leggiFrazione();
f2 = leggiFrazione(); f2 = leggiFrazione();
somma = somma = riduci( riduci(sum(f1,f2) sum(f1,f2)) ); ;
printf("%d/%d",somma.num,somma.den); printf("%d/%d",somma.num,somma.den);
} }
1 1
Modificabilit Modificabilit
oi definisco la nuova funzione oi definisco la nuova funzione riduci riduci
er ridurre una er ridurre una frazione frazione ai minimi termini, basta ai minimi termini, basta
dividere numeratore e denominatore per il loro dividere numeratore e denominatore per il loro
MC MC
frazione riduci(frazione f) frazione riduci(frazione f)
{ { int int m = MCD( m = MCD(f.num f.num, ,f.den f.den); );
f.num f.num = = f.num f.num/m; /m;
f.den f.den = = f.den f.den/m; /m;
return return f; f;
} } 2 2
In C, i parametri sono trasferiti sempre e solo In C, i parametri sono trasferiti sempre e solo
per valore per valore ( (by aIue by aIue o o per opia per opia) )
OO si trasferise si trasferise una coia una coia del parametro attuale, del parametro attuale,
non I'oiginaIe non I'oiginaIe! !
OO tale opia tale opia seamene iaa e IocaIe a queI seamene iaa e IocaIe a queI
seioe seioe
OO il servitore potrebbe quindi il servitore potrebbe quindi alterare il valore alterare il valore
rievuto rievuto, , senza che ci abbia aIcun imao suI senza che ci abbia aIcun imao suI
cIiene cIiene
PASSAGGIO EI PARAMETRI I C PASSAGGIO EI PARAMETRI I C

In C, i parametri sono trasferiti sempre e solo In C, i parametri sono trasferiti sempre e solo
per valore per valore ( (by by aIue aIue o o per opia per opia) )
Conseguenza: Conseguenza:
OO impossibile usare un parametro per impossibile usare un parametro per asfeie asfeie
infomazioni eso iI cIiene infomazioni eso iI cIiene
OO per trasferire un'informazione al liente si per trasferire un'informazione al liente si
sfrutta il sfrutta il aIoe di iono aIoe di iono della funzione della funzione
PASSAGGIO EI PARAMETRI I C PASSAGGIO EI PARAMETRI I C

OO si trasferise si trasferise una coia deI aIoe una coia deI aIoe del del
parametro attuale parametro attuale
cIiene
z
45
PASSAGGIO PER VAORE PASSAGGIO PER VAORE

OO si trasferise si trasferise una coia deI aIoe una coia deI aIoe del del
parametro attuale parametro attuale
cIiene seioe
z
45
opia
w
45
valore
(opiato)
di z
istanza del
servitore
Ogni azione
fatta su w
loale
al servitore
PASSAGGIO PER VAORE PASSAGGIO PER VAORE

efinizione formale: efinizione formale:
|x|: Z |x|: Z FF
|x| vale x |x| vale x se x se x KK 0 0
|x| vale |x| vale - -x x se x se x < < 0 0
Codifia sotto forma di funzione C: Codifia sotto forma di funzione C:
int int alAss alAss( (int int ) )
{ {
if if (<0) (<0) return return - -; ;
else else return return ; ;
} }
ESEMPIO: VAORE ASSOTO ESEMPIO: VAORE ASSOTO

int alAss(int )
{ if (<0) = -;
return ;
}
main()
{ int absz, z = -87;
absz = alAss(z);
printf("|%d|=%d",z,absz);
}
8 8
OO Servitore Servitore
int int alAss alAss( (int int ) )
{ { if if (<0) = (<0) = - -; ;
return return ; ;
} }
Cliente Cliente
main main() ()
{ { int int absz absz, z = , z = - -87; 87;
absz absz = = alAss alAss(z); (z);
printf printf(|%d|=%d,z, (|%d|=%d,z,absz absz); );
} }
ESEMPIO: VAORE ASSOTO ESEMPIO: VAORE ASSOTO
Quando valAss(z) viene iamata,
il valore attuale di z, valutato
nell'environment orrente (-87),
viene opiato e passato a valAss.
Quindi x vale -87
-87

OO Servitore Servitore
int int alAss alAss(int ) (int )
{ { if (<0) = if (<0) = - -; ;
return ; return ;
} }
Cliente Cliente
main main() ()
{ { int absz, z = int absz, z = - -87; 87;
absz = absz = alAss alAss(z); (z);
printf(|%d|=%d,z,absz); printf(|%d|=%d,z,absz);
} }
ESEMPIO: VAORE ASSOTO ESEMPIO: VAORE ASSOTO
-87 87

valAss restituise il valore 87 e

viene assegnato a absz
OTA: I VAORE I z O
VIEE MOIICATO
0 0
OO Servitore Servitore
int int alAss alAss( (int int ) )
{ { if if (<0) = (<0) = - -; ;
return return ; ;
} }
Cliente Cliente
main main() ()
{ { int int absz absz, z = , z = - -87; 87;
absz absz = = alAss alAss(z); (z);
printf(|%d|=%d,z, printf(|%d|=%d,z,absz absz); );
} }
ESEMPIO: VAORE ASSOTO ESEMPIO: VAORE ASSOTO
OTA: I VAORE I z O
VIEE MOIICATO
la printf stampa
|-87| = 87
1 1
Vantaggi: Vantaggi:
OO vita di effettuare modifiche "per sbaglio sulle vita di effettuare modifiche "per sbaglio sulle
variabili del cliente variabili del cliente
imiti: imiti:
OO consente di restituire al cliente consente di restituire al cliente soIo aIoi di io soIo aIoi di io
eIaiamene semIice eIaiamene semIice
OO non consente di restituire non consente di restituire coIIezioni coIIezioni di valori di valori
OO non onsente di srivere omponenti software il non onsente di srivere omponenti software il
ui sopo sia ui sopo sia dieso daI caIcoIo di una dieso daI caIcoIo di una
esessione esessione
PASSAGGIO EI PARAMETRI I C PASSAGGIO EI PARAMETRI I C
2 2
Molti linguaggi mettono a disposizione il Molti linguaggi mettono a disposizione il
passaggio per riferimento ( passaggio per riferimento (by by reerence reerence) )
OO non si trasferisce non si trasferisce una copia del valore una copia del valore del del
parametro attuale parametro attuale
OO si traserisce un rierimento al parametro si traserisce un rierimento al parametro, , in in
modo da dare al servitore modo da dare al servitore accesso diretto accesso diretto al al
parametro in possesso del cliente parametro in possesso del cliente
OO il servitore il servitore accede e modiica direttamente accede e modiica direttamente il dato il dato
del cliente. del cliente.
PASSAGGIO EI PARAMETRI PASSAGGIO EI PARAMETRI

Il C Il C non non supporta supporta dieamene dieamene il passaggio il passaggio
per riferimento per riferimento
OO una grave mancanza! una grave mancanza!
OO il C lo fornisce indirettamente solo per alcuni il C lo fornisce indirettamente solo per alcuni
tipi di dati tipi di dati
OO quindi, occorre costruirselo quando serve. quindi, occorre costruirselo quando serve.
(edremo pi aanti dei casi) (edremo pi aanti dei casi)
PASSAGGIO EI PARAMETRI I C PASSAGGIO EI PARAMETRI I C

sercizio sercizio
Calcolare la funzione seno di x con la seguente Calcolare la funzione seno di x con la seguente
formula formula (fermarsi ad un esponente dato come (fermarsi ad un esponente dato come
parametro) parametro)::
l fattoriale di un numero definito come l fattoriale di un numero definito come
n n! = 1 ! = 1 se n se n = 0 = 0
n n!!= n = n( (n n- -1)! 1)! se n se n > 0 > 0
n pratica, si pu calcolare come n pratica, si pu calcolare come
n n!= 1 x 2 x 3 x x != 1 x 2 x 3 x x n n

Soluzione Soluzione
Ragionamento bottom Ragionamento bottom- -up: up:
ossiamo riutilizzare le funzioni che gi ossiamo riutilizzare le funzioni che gi
conosciamo: la potenza di un numero conosciamo: la potenza di un numero
Ci manca la funzione fattoriale Ci manca la funzione fattoriale

Fattoriale (iterativo) Fattoriale (iterativo)
int int fact fact( (int int n) n)
{ { int int i,f=1; i,f=1;
for for (i=1;i (i=1;i< <=n =n;i ;i++) ++)
f=f*i; f=f*i;
return return f; f;
} }

ra possiamo definire la funzione sen ra possiamo definire la funzione sen
float sen(float , int precisione) float sen(float , int precisione)
{ { int i, segno=1; int i, segno=1;
float ris=0; float ris=0;
for (i=1;i<precisione;i=i+2) for (i=1;i<precisione;i=i+2)
{ {
ris=ris+segno*power(,i)/fact(i); ris=ris+segno*power(,i)/fact(i);
segno = segno = - -segno; segno;
} }
return ris; return ris;
} }
8 8
rdine delle funzioni rdine delle funzioni
er il C, vale una regola fondamentale: er il C, vale una regola fondamentale:
"n identificatore non visibile "n identificatore non visibile
prima della sua dichiarazione prima della sua dichiarazione
'abbiamo gi visto per le variabili: lo 'abbiamo gi visto per le variabili: lo
stesso concetto vale anche per le stesso concetto vale anche per le
funzioni funzioni

uindi . uindi .
int power(int a, int b) int power(int a, int b)
{ { int i,p=1; int i,p=1;
for (i=0;i<b;i++) for (i=0;i<b;i++)
p = p*a; p = p*a;
return p; return p;
} }
int fact(int n) int fact(int n)
{ { int i,f=1; int i,f=1;
for (i=1;i<n;i++) for (i=1;i<n;i++)
f=f*i; f=f*i;
return f; return f;
} }
float sen(float , int precisione) float sen(float , int precisione)
{ { int i, segno=1; int i, segno=1;
float ris=0; float ris=0;
for (i=1;i<precisione;i=i+2) for (i=1;i<precisione;i=i+2)
{ris=ris+segno* {ris=ris+segno*power power(,i)/ (,i)/fact fact(i); (i);
segno = segno = - -segno; segno;
} }
return ris; return ris;
} }
main() main()
{ { printf($f, printf($f,sen sen(0.1,4);} (0.1,4);}
main() main()
{ { printf($f, printf($f,sen sen(0.1,4);} (0.1,4);}
int power(int a, int b) int power(int a, int b)
{ { int i,p=1; int i,p=1;
for (i=0;i<b;i++) for (i=0;i<b;i++)
p = p*a; p = p*a;
return p; return p;
} }
float sen(float , int precisione) float sen(float , int precisione)
{ { int i, segno=1; int i, segno=1;
float ris=0; float ris=0;
for (i=1;i<precisione;i=i+2) for (i=1;i<precisione;i=i+2)
{ris=ris+segno* {ris=ris+segno*power power(,i)/ (,i)/fact fact(i); (i);
segno = segno = - -segno; segno;
} }
return ris; return ris;
} }
int fact(int n) int fact(int n)
{ { int i,f=1; int i,f=1;
for (i=1;i<n;i++) for (i=1;i<n;i++)
f=f*i; f=f*i;
return f; return f;
} }
k!
o!
80 80
rototipi rototipi
n realt, per riuscire ad invocare il n realt, per riuscire ad invocare il
servitore, il cliente ha bisogno solo servitore, il cliente ha bisogno solo
dell'interfaccia dell'interfaccia
er questo, si pu definire la sola er questo, si pu definire la sola
interfaccia e poi dare la definizione della interfaccia e poi dare la definizione della
funzione pi avanti. funzione pi avanti.
81 81
a a dichiarazione dichiarazione di una funzione (o di una funzione (o
prototipo prototipo della funzione) costituita della funzione) costituita
dalla dalla sola interfaccia, sola interfaccia, senza corpo senza corpo
(sostituito da un (sostituito da un ) )
<<dichiarazione dichiarazione- -di di- -funzione funzione> ::= > ::=
<<tipoalore tipoalore>> <nome>( <nome>(<parametri> <parametri>) )
ICHIARAIOE ICHIARAIOE I I IOE IOE
82 82
sempio sempio
int int power power( (int int a, a, int int b); b);
main main() ()
{ { printf(" printf("%d %d", ",power power(2,3)); (2,3));
} }
int int power power( (int int a, a, int int b) b)
{ { int int i,p=1; i,p=1;
for for (i=0;i<b;i++) (i=0;i<b;i++)
p = p = p*a p*a; ;
return return p; p;
} }
k!
8 8
a a deinizione deinizione di una funzione costituisce di una funzione costituisce
l'effettiva realizzazione l'effettiva realizzazione del componente del componente
ice come fatto il componente ice come fatto il componente
a a dichiarazione dichiarazione specifica il specifica il contratto di contratto di
servizio servizio fra cliente e servitore, esprimendo le fra cliente e servitore, esprimendo le
propriet essenziali della funzione. propriet essenziali della funzione.
ice come si usa il componente ice come si usa il componente
er usare una funzione non necessario sapere er usare una funzione non necessario sapere
come fatta, anzi, controproducente come fatta, anzi, controproducente
ICHIARAIOE ICHIARAIOE I I IOI IOI
8 8
sempio sempio
int int power power(int a, int b); (int a, int b);
main main() ()
{ { printf(" printf("%d %d", ",power power(2,3)); (2,3));
} }
int int power power(int a, int b) (int a, int b)
{ { int i,p=1; int i,p=1;
for for (i=0;i<b;i++) (i=0;i<b;i++)
p = p = p*a p*a; ;
return return p; p;
} }
definizione
dichiarazione
8 8
a a deinizione deinizione di una funzione costituisce di una funzione costituisce
l'effettiva realizzazione l'effettiva realizzazione del componente del componente
on pu essere duplicata on pu essere duplicata
gni applicazione deve contenere una e una sola gni applicazione deve contenere una e una sola
definizione per ogni funzione utilizzata definizione per ogni funzione utilizzata
a compilazione della definizione genera il codice a compilazione della definizione genera il codice
macchina che verr eseguito ogni volta che la macchina che verr eseguito ogni volta che la
funzione verr chiamata. funzione verr chiamata.
ICHIARAIOE vs. EIIIOE ICHIARAIOE vs. EIIIOE
int int power power( (int int a, a, int int b) b)
{ { int int i,p=1; i,p=1;
for for (i=0;i<b;i++) (i=0;i<b;i++)
p = p = p*a p*a; ;
return return p; p;
} }
definizione
8 8
a a dichiarazione dichiarazione di una funzione costituisce di una funzione costituisce
solo una specifica solo una specifica delle propriet del delle propriet del
componente: componente:
u essere duplicata senza danni u essere duplicata senza danni
n'applicazione pu contenerne pi di una n'applicazione pu contenerne pi di una
a compilazione di una dichiarazione non genera a compilazione di una dichiarazione non genera
codice macchina codice macchina
ICHIARAIOE vs. EIIIOE ICHIARAIOE vs. EIIIOE
int int power power( (int int a, a, int int b); b);
dichiarazione
8 8
a a definizione definizione molto pi molto pi di una di una
dichiarazione dichiarazione
definizione definizione == dichiarazione dichiarazione + + corpo corpo
a definizione funge anche da dichiarazione a definizione funge anche da dichiarazione
(ma non viceversa) (ma non viceversa)
ICHIARAIOE vs. EIIIOE ICHIARAIOE vs. EIIIOE
88 88
sempio sempio
int primo(int n) int primo(int n)
{ { int i=2,diisibile=0; int i=2,diisibile=0;
while while ((!diisibile) && (i<n)) ((!diisibile) && (i<n))
{ { diisibile = (n % i)==0; diisibile = (n % i)==0;
i++; i++;
} }
return return (!diisibile); (!diisibile);
} }
main main() ()
{ { int n; int n;
scanf(" scanf("%d %d", ",&n &n); );
if if (primo(n)) (primo(n))
printf(" printf("%d %d e` primo",n); e` primo",n);
else printf(" else printf("%d %d non e` primo",n); non e` primo",n);
} }
osso renderlo
pi eiciente!
8 8
sempio sempio
int primo(int n) int primo(int n)
{ { int i=3,diisibile=0; int i=3,diisibile=0;
if if (n<=2) (n<=2) return return 1; 1;
if if (n % 2 ==0) (n % 2 ==0) return return 0; 0;
else else
{ { while while ((!diisibile) && (i<n/2)) ((!diisibile) && (i<n/2))
{ { diisibile = (n % i)==0; diisibile = (n % i)==0;
i=i+2 i=i+2; ;
} }
return return (!diisibile); (!diisibile);
} }
} }
main main() ()
{ { int n; int n;
scanf(" scanf("%d %d", ",&n &n); );
if if (primo(n)) (primo(n))
printf(" printf("%d %d e` primo",n); e` primo",n);
else printf(" else printf("%d %d non e` primo",n); non e` primo",n);
} }
0 0
sercizio sercizio
Si scriva una funzione in linguaggio C che Si scriva una funzione in linguaggio C che
calcola il valore della funzione matematica calcola il valore della funzione matematica
" "( (n n) ), definita come "il numero di numeri , definita come "il numero di numeri
primi compresi fra primi compresi fra 1 1 ed n ed n
" "(1)=0 (1)=0
" "(2)=1 (2)=1 {2} {2}
" "(3)=2 (3)=2 {2,3} {2,3}
" "(4)=2 (4)=2 {2,3} {2,3}
" "(5)=3 (5)=3 {2,3,5} {2,3,5}
1 1
sercizio sercizio
Si definisca il tipo di dato "numero Si definisca il tipo di dato "numero
complesso, come una struttura complesso, come una struttura cpl cpl con con
campi campi re re (parte reale) e (parte reale) e im im (parte (parte
immaginaria) immaginaria)
Si scrivano due funzioni, che forniscono il Si scrivano due funzioni, che forniscono il
modulo e l'angolo del numero complesso modulo e l'angolo del numero complesso
Funzioni utili (in Funzioni utili (in math.h math.h): ):
atan atan : arcotangente : arcotangente
sqrt sqrt : radice quadrata : radice quadrata