Fondamenti di Informatica I CDL in Ingegneria Elettronica - A.A. 2007-2008 CDL in Ingegneria Elettronica - A.A. 2007-2008 9. Funzioni e procedure Ing

Fondamenti di Informatica IFondamenti di Informatica I

CDL in Ingegneria Elettronica - A.A. 2007-2008CDL in Ingegneria Elettronica - A.A. 2007-2008

9. Funzioni e procedure9. Funzioni e procedure Ing. Ing. Simona ColucciSimona Colucci

Sistemi Sistemi InformativiInformativiDEE - Politecnico di BariDEE - Politecnico di Bari

Fondamenti di Informatica IFondamenti di Informatica I CDL in Ingegneria Elettronica - A.A. 2007-2008CDL in Ingegneria Elettronica - A.A. 2007-2008

IndiceIndice

• Necessità di sottoprogrammi(funzioni e procedure)

• Struttura completa di un programma in C• Funzioni• Procedure• Comunicazione con i sottoprogrammi• Sottoprogrammi predefiniti



Il concetto di sottoprogramma (1)Il concetto di sottoprogramma (1)

• I sottoprogrammi implementano operazioni non predefinite sui tipi di dati

• Ai meccanismi di astrazione sui dati visti finora mancano infatti le operazioni:– Esempio (di tipi di dati definiti):

typedef struct { int NumFatture;DescrizioneFatture Sequenza[MaxNumFatture];} ElencoFatture;

typedef struct { int NumCosti;Descrizionecosti Sequenza[MaxNumCosti]} ElencoCosti;

MaxNumFatture e MaxNumCosti costanti DescrizioneFatture e DescrizioneCosti tipi definiti (in precedenza):




• I sottoprogrammi racchiudono in maniera astratta le righe di codice necessarie ad eseguire un’operazione

• Vantaggi:– Scrivere direttamente il risultato

RisultatoDiGestione = FatturatoTotale (ArchivioFatture) – SommaCosti (ArchivioCosti);

è meglio che scrivere tutte le istruzioni necessarie ad ottenerlo

FatturatoTotale = 0;for (Cont = 0; Cont < ArchivioFatture.NumFatture; Cont++){

FatturatoTotale = FatturatoTotale + ArchivioFatture.Sequenza[Cont].Importo;}SommaCosti= 0;for (Cont = 0; Cont < ArchivioCosti.NumCosti; Cont++){

SommaCosti = SommaCosti + ArchivioCosti.Sequenza[Cont].Importo;}RisultatoDiGestione = FatturatoTotale – SommaCosti;

– Se l’operazione deve essere ripetuta più volte l’utilizzo dei sottoprogrammi è ancora più vantaggioso




• I sottoprogrammi sono lo strumento per realizzare astrazioni sulle operazioni

• Due tipi (concettualmente):– Funzioni: sottoprogrammi descrivibili come vere e proprie

funzioni matematiche e possiedono un dominio ed un codominio– Procedure: sottoprogrammi che modificano lo stano di alcune

variabili di programma

• L’utilizzo dei sottoprogrammi necessita di:– Definizione del sottoprogramma– Chiamata del sottoprogramma



Struttura di un programma CStruttura di un programma C

Struttura completa: Direttive al preprocessore; parte dichiarativa globale

contiene la dichiarazione di tutti gli elementi che sono condivisi dal programma principale e dai sottoprogrammi

Programma principale(main) a sua volta costituito da parte dichiarativa ed esecutiva

definizioni di sottoprogrammi funzioni o procedure a seguire il programma principale.

Il main è un particolare sottoprogramma tra gli altri; Il main e ciascun sottoprogramma possono usare tutti e soli gli

elementi che sono stati dichiarati nella loro propria parte dichiarativa, nonché quelli che sono stati dichiarati nella parte dichiarativa globale



Funzioni: DefinizioneFunzioni: Definizione

• Struttura della definizione : testata (header); due parti, racchiuse fra parentesi graffe:

• la parte dichiarativa locale: definisce tutti gli oggetti necessari alla realizzazione dell’operazione astratta, in particolare le variabili locali

• la parte esecutiva (detta corpo della funzione):– Istruzioni per l’esecuzione dell’operazione– Istruzione di return: serve a restituire il risultato della

funzione, del tipo specificato nella testata e identificato tramite il nome della funzione



Funzioni : DefinizioneFunzioni : Definizione

• La testata contiene: – tipo del risultato(codominio della funzione)

• Una funzione non può restituire array o funzioni ma può restituire un puntatore a qualsiasi tipo

– identificatore del sottoprogramma– lista dei parametri (formali) cui la funzione

viene applicata con il relativo tipo(dominio della funzione): • Ogni parametro formale è un identificatore di tipo

seguito da un identificatore• Si chiamano formali perché non hanno valore proprio

ma sono riferimenti simbolici agli argomenti delle funzioni




Esempi di testate:

• int FatturatoTotale(ElencoFatture par)

• boolean Precede(StringaCaratteri par1, StringaCaratteri par2)

• boolean Esiste(int par1, SequenzaInteri par2)/* Stabilisce se il primo parametro, di tipo intero, appartiene all'insieme di

interi contenuti nel secondo parametro: una sequenza di interi */

• MatriceReali10Per10 *MatriceInversa(MatriceReali10Per10 *par)




Funzione completa:

int FatturatoTotale (ElencoFatture parametro){

int Totale, Cont;

Totale = 0;for (Cont = 0; Cont < parametro.NumFatture; Cont++)

Totale = Totale + parametro.Sequenza[Cont].Importo;return Totale;

}




Funzione completa:

int RadiceIntera (int par){

int cont;

cont = 0;while (cont*cont <= par)

cont = cont + 1;return (cont – 1);

}



Funzioni: ChiamataFunzioni: Chiamata

• Consentono di utilizzare le operazioni implementate dalle funzioni

• Una funzione applicata a un valore dell’argomento, appartenente al suo dominio, fornisce un valore appartenente al suo codominio

• Struttura della chiamata:– Identificatore della funzione– Lista dei parametri attuali, tra parentesi tonde:

• Sono i valori degli argomenti rispetto ai quali la funzione deve essere calcolata

• Corrispondono in numero, ordine e tipo ai parametri formali dichiarati



Funzioni: chiamataFunzioni: chiamata

Esempi:

• x = sin(y) – cos(PiGreco – alfa);• x = cos(atan(y) – beta);• x = sin(alfa);• y = cos(alfa) – sin(beta);• z = sin(PiGreco) + sin(gamma);

• RisultatoGestione = FatturatoTotale(ArchivioFatture) - SommaCosti(ArchivioCosti);

• Det1 = Determinante(Matrice1);• Det2 = Determinante(MatriceInversa(Matrice2));

• TotaleAssoluto = Sommatoria(Lista1) + Sommatoria(Lista2);• ElencoOrdinato = Ordinamento(Elenco);• OrdinatiAlfabeticamente = Precede(nome1, nome2);



• All’interno di un programma C una funzione può essere chiamata purché risulti definita oppure dichiarata(definizione e dichiarazione non sono termini equivalenti)

• La dichiarazione di una funzione (prototipo):– si limita a richiamarne la testata– Utile quando la chiamata di una funzione precede, nel codice, la

definizione della funzione, oppure le funzioni utilizzate da un programma sono definite in file propri del sistema C (e.g., le funzioni di libreria)

– Aiuta il compilatore ed è buono stile di programmazione

Prototipo delle funzioniPrototipo delle funzioni



Esecuzione delle funzioniEsecuzione delle funzionie passaggio dei parametrie passaggio dei parametri

/* Programma Contabilità (1) *//* Parte direttiva */

#include <stdio.h>#define MaxNumFatture 1000

/* Parte dichiarativa globale */typedef char String [30];typedef struct { String Indirizzo;

int Ammontare;Data DataFattura;

} DescrizioneFatture;typedef struct { int NumFatture;

DescrizioneFatture Sequenza[MaxNumFatture];} ElencoFatture;



/* Programma Contabilità (2)*/main() {

ElencoFatture ArchivioFatture1, ArchivioFatture2;int Fatt1, Fatt2, Fatt;

int FatturatoTotale(ElencoFatture parametro);/* Prototipo della funzione FatturatoTotale */

....Fatt1 = FatturatoTotale(ArchivioFatture1);Fatt2 = FatturatoTotale(ArchivioFatture2);Fatt = Fatt1 + Fatt2;....

}/* Fine del main del programma Contabilità */




/* Definizione della funzione FatturatoTotale */

int FatturatoTotale (ElencoFatture parametro){

int Totale, Cont;Totale = 0;for (Cont = 0; Cont < parametro.NumFatture; Cont++)Totale = Totale + parametro.Sequenza[Cont].Importo;

return Totale;}




Esecuzione di funzioni:Esecuzione di funzioni:macchine astratte master e slavemacchine astratte master e slave

ArchivioFatture1

ArchivioFatture2

Fatt1

Fatt2

Parametro

Totale

Cont

FatturatoTotale

MASTER: chiama la funzione passando i parametri attuali

SLAVE: calcola il risultato dopo aver manipolato i parametri formali



Esecuzione di funzioni:Esecuzione di funzioni:macchine astratte master e slavemacchine astratte master e slave

• Le due macchine hanno ciascuna il proprio ambiente di esecuzione: – La macchina slave ha un ambiente locale di funzione

caratterizzato da:• Variabili locali• Variabili corrispondenti ai parametri formali• Variabile che contiene il valore da restituire (tramite

l’istruzione return), che corrisponde all’identificatore della funzione nel modulo master

– La macchina master ha un ambiente caratterizzato dalle variabili che utilizza il programma chiamante, tra cui quelle passate come parametri attuali



Passaggio di parametriPassaggio di parametri

L’istruzione:Fatt1 = FatturatoTotale(ArchivioFatture1);

provoca il seguente flusso:– La macchina master chiama la macchina slave per il

valore di FatturatoTotale passando i parametri ad essa:il passaggio dei parametri consiste nella copiatura dei parametri attuali nella cella dei parametri formali

– Il controllo viene ceduto alla macchina slave, che procede con l’esecuzione come un normale programma fino al return o alla chiusura di parentesi graffa

– Il controllo viene restituito alla macchina master con la restituzione del valore della funzione




x = sin(atan(y) – acos(z));

Equivale a :

temp1 = atan(y); temp2 = acos(z);

temp3 = temp1 – temp2

x = sin(temp3);



ProcedureProcedure

• Sono sottoprogrammi che non corrispondono a funzioni matematiche

• Le procedure non servono a produrre dei valori di un certo tipo ma a modificare lo stato del programma che ne chiede l’esecuzione

• In C una procedura viene definita come una funzione che ha come tipo del risultato il tipo speciale void



Procedure: esempio 1Procedure: esempio 1

typedef enum {VerdeSinistra, VerdeDestra} TipoStato;typedef struct { TipoStato Stato;

int CodaSinistra; int CodaDestra;} TipoSemaforo;

TipoSemaforo Semaforo;

AggiornaSemaforo :

• Diminuisce di un valore costante il campo CodaSinistra o CodaDestra a seconda che lo stato del semaforo sia VerdeSinistra o VerdeDestra;

• Legge dal terminale i valori NuoviArriviSinistri e NuoviArriviDestri e li somma, rispettivamente, a CodaSinistra e CodaDestra;

• Dà al campo Stato il valore VerdeSinistra se CodaSinistra > Coda Destra e viceversa.



Procedure : esempio 2Procedure : esempio 2

/*Programma Contabilità (1)*/

#include<stdio.h>#define MaxNumFatture 1000...typedef struct { String indirizzo;

int ammontare;Data DataFattura;

} DescrizioneFatture;typedef struct { int NumFatture;

DescrizioneFattureSequenza[MaxNumFatture];} ElencoFatture;

ElencoFatture ArchivioFatture;




main(){

Data DataOdierna;DescrizioneFatture Fattura1, Fattura2;void InserisciFattura(DescrizioneFatture Fattura);boolean Precede(Data Num1, Data Num2);…

/* Sequenza di istruzioni che leggono i dati di una fattura in Fattura1 */InserisciFattura(Fattura1);...

/* Sequenza di istruzioni che leggono i dati di una fattura in Fattura2 */

if (Precede(Fattura2.DataEmissione, DataOdierna))InserisciFattura(Fattura2);

...}

Procedure: esempio 2Procedure: esempio 2




void InserisciFattura(DescrizioneFatture Fattura){

if (ArchivioFatture.NumFatture == MaxNumFatture)printf("L'archivio è pieno.\n");

else{

ArchivioFatture.NumFatture = ArchivioFatture.NumFatture + 1;ArchivioFatture.Sequenza[ArchivioFatture.NumFatture–1] = Fattura;

}}

Procedure : esempio 2Procedure : esempio 2



Ambiente globale

ArchivioFatture

Ambiente locale di InserisciFattura

Ambiente di main di Programma Contabilità

DataOdierna Fattura

Fattura1

Fattura2

...

Esecuzione delle procedureEsecuzione delle procedure



Passaggio parametri per indirizzo (1)Passaggio parametri per indirizzo (1)

void InserisciFattura( DescrizioneFatture Fattura, ElencoFatture ArchivioFatture)

/*In questa versione della procedura, sia la fattura da inserire sia l'archivio in cui inserirla sono dei parametri */

{

if (ArchivioFatture.NumFatture == MaxNumFatture)

printf("L'archivio è pieno.");

else

{

ArchivioFatture.NumFatture = ArchivioFatture.NumFatture + 1;

ArchivioFatture.Sequenza[ArchivioFatture.NumFatture–1] = Fattura;

}

}

/*Fine della procedura InserisciFattura */

InserisciFattura (Fattura1, ArchivioFatture5); Non funziona! Perché?



Ind(x) = 2034

Parametri attuali Parametri formali

Passaggio per valore

243 243

Ind(y) = 1004Passaggio per indirizzo

y A

413 1004




In C la modalità di passaggio dei parametri a un sottoprogramma è sempre quella di passaggio

per valore. Per simulare il passaggio per indirizzo:• utilizzare il costruttore puntatore per la

definizione dei parametri formali della funzione;

• usare l’operatore di dereferenziazione di puntatore (operatore * o –>) all’interno del corpo della funzione;

• passare al momento della chiamata della funzione come parametro attuale un indirizzo di variabile (usando l’operatore &).




/*Programma Contabilità (1)*/...main(){ElencoFatture ArchivioFatture5;

/* Qui ArchivioFatture5 è una variabile locale del main. */Data DataOdierna;DescrizioneFatture Fattura1, Fattura2;

void InserisciFattura ( DescrizioneFatture Fattura,ElencoFatture *PointToArchivioFatture);/* Prototipo della procedura InserisciFattura */

Boolean Precede(Data Num1, Data Num2);/* Prototipo della funzione Precede */




/*Programma Contabilità (2)*/...


InserisciFattura(Fattura1, &ArchivioFatture5);/* Chiamata della procedura InserisciFattura: alla procedura viene passato

il valore di Fattura1 e l'indirizzo di ArchivioFatture5 */...


if (Precede(Fattura2.DataEmissione, DataOdierna)InserisciFattura(Fattura2,&ArchivioFatture5);

/* Nuova chiamata della procedura InserisciFattura: alla procedura viene passato il valore di Fattura2 e -nuovamente- l'indirizzo di Archivio Fatture5

(ma potrebbe essere un altro) */...

}




/*Programma Contabilità (3)*/...

/* Definizione della procedura InserisciFattura */void InserisciFattura( DescrizioneFatture Fattura,

ElencoFatture *PointToArchivioFatture)/* In questa versione della procedura, la fattura da inserire e l'indirizzo

dell'archivio in cui inserirla sono dei parametri */{

if (PointToArchivioFatture–>NumFatture == MaxNumFatture)/* PointToArchivioFatture è una variabile che punta a una struttura

avente un campo di nome NumFatture */printf("L'archivio è pieno.\n");

else{

PointToArchivioFatture–>NumFatture = PointToArchivioFatture–>NumFatture +1;PointToArchivioFatture–>Sequenza[PointToArchivioFatture–>NumFatture – 1] = Fattura;

}}




I blocchiI blocchi

• Un blocco è composto da due parti racchiuse tra parentesi graffe: una parte dichiarativa (facoltativa); una sequenza di istruzioni.

• Diversi blocchi possono comparire internamente al main o alle funzioni che compongono un programma C. I blocchi possono risultare paralleli o annidati



/* Programma ComplessoInStruttura */#include <stdio.h>

/* Parte dichiarativa globale */int g1, g2;char g3;int f1(int par1, int par2); ...main (){ int a, b;

int f2(int par3, int par1); .../* blocco1 */

{ char a, c;...

/* blocco2 annidato nel blocco1 */{ float a;

...}

/* Fine blocco2 */ }

/* Fine blocco1 */}

/* Fine main */

I blocchi annidatiI blocchi annidati



int f1(int par1, int par2){

int d; ...

/* blocco3 */ { int e;

... }

/* Fine blocco3 *//* blocco4 */

{ int d;

... }

/* Fine blocco4 */}

/* Fine f1 */

I blocchi paralleliI blocchi paralleli



/* Definizione della funzione f2 */int f2(int par3, int par4){

int f; ...

}/* Fine f2 */

I blocchi : funzioniI blocchi : funzioni



Visibilità all’interno dei blocchiVisibilità all’interno dei blocchi



La durata delle variabiliLa durata delle variabili

• variabili fisse o statiche (static): i loro valori vengono mantenuti anche all’esterno del loro ambito di visibilità.

• variabili automatiche (auto): i loro valori non vengono mantenuti all’esterno del proprio ambito di visibilità.

• Sono variabili fisse le variabili globali del programma



/* Definizione della funzione f1 */

int f1(int par1, intpar2)

{

static int d;

/* blocco3 */

{ int e;

...

} /*Fine blocco3 */

/* blocco4 */

{ int d;

...

}

/* Fine blocco4 */

} /* Fine f1 */

La durata delle variabili: esempioLa durata delle variabili: esempio



Parametri di tipo arrayParametri di tipo array

• L’indirizzo di base dell’array viene passato “per valore” alla funzione.

typedef double TipoArray[MaxNumElem]

• Le tre testate di funzione riportate di seguito sono equivalenti:

double sum(TipoArray a, int n) /* n è la dimensione dell'array passato */

double sum(double *a, int n)double sum(double a[ ], int n)



Parametri di tipo arrayParametri di tipo array

double mul(double a[ ], int n)/* n è la dimensione dell'array passato */

{int i;double ris;

ris = 1.0;for (i=0; i < n; i=i+1)

ris = ris * a[i];return ris;

}

• v array di 50 elementi:

Chiamata Valore calcolato e restituito

mul(v, 50) v[0]*v[1]* ... *v[49]

mul(v, 30) v[0]*v[1]* ... *v[29]

mul(&v[5], 7) v[5]*v[6]* ... *v[11]

mul(v+5, 7) v[5]*v[6]* ... *v[11]



Parametri di tipo strutturaParametri di tipo struttura

• Una struttura può essere passata per valore anche quando contiene un componente di tipo array.



Effetti collaterali (1)Effetti collaterali (1)

int x; /* Variabile globale */

int PrimoEsempio(int par){

return (par + x)}

• Nel corso del seguente frammento di programma:

x = 1;x = PrimoEsempio(1);x = PrimoEsempio(1);

• La sua chiamata produce, la prima volta, il risultato “2”, la seconda volta “3”.



int SecondoEsempio(int *par){

*par = *par + 1;return *par;

}

y = SecondoEsempio(&z);

• Assegna alla variabile y il valore di z+1, ma anche z assume lo stesso valore. effetto collaterale (side effect)




int x; /* Variabile globale */

int TerzoEsempio(int par){

x = par + 2;return (par + 1);

}

• Altro effetto collaterale:

z = TerzoEsempio(4);

• Assegna a z il valore “5”, ma anche il valore “6” a x. A




Uso interscambiabile Uso interscambiabile di procedure e funzionidi procedure e funzioni

int f(int par1){

...return risultato;

}

• Essa può essere trasformata nella procedura seguente:

void f(int par1, int *par2){

...*par2 = risultato;

}

• Successivamente, una chiamata come:

y = f(x);

verrà trasformata in:

f(x, &y);



La standard libraryLa standard library del Cdel C

• Sottoprogrammi di largo uso predefiniti:– Matematica– I/O– Grafica

• Librerie di sottoprogrammi:– Predefinite– Costruite dai programmatori applicativi

• Però l’uso di librerie diminuisce la portabilità a meno che anche le librerie (almeno le fondamentali) non siano standardizzate: la grande forza del C: la libreria standard



#include <stdio.h> /* Programma Concatenazione di stringhe */#include <string.h>#define LunghezzaArray 50main(){

char PrimaStringa[LunghezzaArray], SecondaStringa[LunghezzaArray],StringaConc[2 * LunghezzaArray];

unsigned LunghezzaConc;scanf(“%s”, PrimaStringa);scanf(“%s”, SecondaStringa);if (strcmp(PrimaStringa, SecondaStringa) <= 0){

strcpy(StringaConc, PrimaStringa);strcat(StringaConc, SecondaStringa);

}else{

strcpy(StringaConc, SecondaStringa);strcat(StringaConc, PrimaStringa);

}LunghezzaConc = strlen(StringaConc);printf(“La stringa ottenuta concatenando le due stringhe lette è %s.

Essa è lunga %d caratteri\n”, StringaConc, LunghezzaConc);}

EsempioEsempio



I file headerI file header

• Le funzioni della libreria sono disponibili in C come file di codice compilato

• È compito del programmatore inserire nel programma i prototipi delle funzioni che verranno usate

• La libreria C comprende alcuni file, chiamati header file, che contengono i prototipi di un insieme di funzioni di libreria

#include <stdio.h>

e altre

#include <xxx.h>

• Il preprocessore copia il contenuto del file stdio.h nel programma, inserendo i prototipi delle funzioni che appartengono al gruppo di cui xxx.h è il file testata

Documents

Fondamenti di Informatica I CDL in Ingegneria Elettronica - A.A. 2007-2008 CDL in Ingegneria Elettronica - A.A. 2007-2008 9. Funzioni e procedure Ing