La dichiarazione di una funzione è costituita dalla sola interfaccia, senza corpo (sostituito da un ; ) ::= ( ) ; DICHIARAZIONI DI FUNZIONE

Perché introdurre la dichiarazione di funzione? Non bastava la definizione..???!? DICHIARAZIONI DI FUNZIONE

Osservazione cruciale: per usare un componente software non c’è bisogno di sapere COME È FATTO basta sapere COME SI USA, cioè - nel caso di una funzione - come va invocata. DICHIARAZIONI DI FUNZIONE

Dunque, non occorre conoscere tutta la definizione basta conoscere la dichiarazione, perché essa specifica proprio il contratto di servizio! DICHIARAZIONI DI FUNZIONE

La definizione di una funzione costituisce l’effettiva realizzazione del componente La dichiarazione specifica il contrat- to di servizio fra cliente e servitore, esprimendo le proprietà essenziali della funzione. DICHIARAZIONI DI FUNZIONE

La definizione di una funzione costituisce l’effettiva realizzazione del componente La dichiarazione specifica il contrat- to di servizio fra cliente e servitore, esprimendo le proprietà essenziali della funzione. DICHIARAZIONI DI FUNZIONE Dice come è fatto il componente

La definizione di una funzione costituisce l’effettiva realizzazione del componente La dichiarazione specifica il contrat- to di servizio fra cliente e servitore, esprimendo le proprietà essenziali della funzione. DICHIARAZIONI DI FUNZIONE Dice come si usa il componente Per usare una funzione non è necessario sapere come è fatta! Anzi… è controproducente!!

La dichiarazione specifica: –il nome della funzione –numero e tipo dei parametri (non necessariamente il nome) –il tipo del risultato DICHIARAZIONI DI FUNZIONE interfaccia

La dichiarazione specifica: –il nome della funzione –numero e tipo dei parametri (non necessariamente il nome) –il tipo del risultato DICHIARAZIONI DI FUNZIONE interfaccia Il nome dei parametri non è necessario: può esserci, ma viene ignorato

La dichiarazione specifica: –il nome della funzione –numero e tipo dei parametri (non necessariamente il nome) –il tipo del risultato DICHIARAZIONI DI FUNZIONE interfaccia Non deve stupire: esso avrebbe significato solo nell’environment della funzione, che qui non c’è! Il nome dei parametri non è necessario: può esserci, ma viene ignorato

La definizione di una funzione costituisce l’effettiva realizzazione del componente DEFINIZIONE vs. DICHIARAZIONE Non può essere duplicata!

La definizione di una funzione costituisce l’effettiva realizzazione del componente DEFINIZIONE vs. DICHIARAZIONE Non può essere duplicata! Una applicazione deve contenere una e una sola definizione per ogni funzione utilizzata

La definizione di una funzione costituisce l’effettiva realizzazione del componente DEFINIZIONE vs. DICHIARAZIONE Non può essere duplicata! Una applicazione deve contenere una e una sola definizione per ogni funzione utilizzata La compilazione di una definizione genera il codice corrispondente alla funzione.

La dichiarazione di una funzione costituisce solo una specifica delle proprietà del componente DEFINIZIONE vs. DICHIARAZIONE Può benissimo essere duplicata senza danni

La dichiarazione di una funzione costituisce solo una specifica delle proprietà del componente DEFINIZIONE vs. DICHIARAZIONE Può benissimo essere duplicata senza danni Una applicazione può contenerne più di una

La dichiarazione di una funzione costituisce solo una specifica delle proprietà del componente DEFINIZIONE vs. DICHIARAZIONE Può benissimo essere duplicata senza danni Una applicazione può contenerne più di una La compilazione di una dichiarazione non genera un solo byte di codice

La definizione è molto più di una dichiarazione –definizione = dichiarazione + corpo DEFINIZIONE vs. DICHIARAZIONE Per questo, la definizione funge anche da dichiarazione (non viceversa!)

Un programma C è, in prima battuta, una collezione di funzioni –una delle quali è il main Il testo del programma deve essere scritto in un file di testo –un concetto del sistema operativo, non del linguaggio C Quali regole osservare ? FUNZIONI & FILE

Il main può essere scritto dove si vuole nel file –viene chiamato dal sistema operativo Una funzione, invece, deve rispettare una regola fondamentale di visibilità –prima che qualcuno possa chiamarla, la funzione deve essere stata dichiarata –altrimenti, si ha errore di compilazione. FUNZIONI & FILE

int fact(int); main() { int y = fact(3); } int fact(int n) { return (n<=1) : 1 : n*fact(n-1); } ESEMPIO Dichiarazione: deve precedere l’uso Uso (chiamata) Definizione File prova1.c

Il main può essere scritto dove si vuole nel file –viene chiamato dal sistema operativo Una funzione, invece, deve rispettare una regola fondamentale di visibilità –prima che qualcuno possa chiamarla, la funzione deve essere stata dichiarata –altrimenti, si ha errore di compilazione. FUNZIONI & FILE Caso particolare: poiché la definizione funge anche da dichiarazione, la regola è rispettata se la definizione appare prima della chiamata

int fact(int n) { return (n<=1) : 1 : n*fact(n-1); } main() { int y = fact(3); } ESEMPIO Definizione: funge an- che da dichiarazione se precede l’uso Uso (chiamata) File prova2.c

FUNZIONI E VARIABILI LOCALI Il corpo di una funzione costituisce un blocco del quale i parametri della funzione sono considerati variabili locali In C e Java, come in molti altri linguaggi, è permessa la definizione di nuove variabili entro il corpo di una funzione

VARIABILI LESSICALI vs. LIBERE Le variabili la cui definizione compare nell’ambito del blocco costituito dal corpo della funzione (inclusi i parametri) vengono chiamate variabili lessicali. Le variabili non definite entro il blocco della funzione (e diverse dai parametri) vengono chiamate variabili libere.

ESEMPIO float fahrToCelsius(float F){ float temp = 5.0 / 9; return temp*(F - trentadue); } Variabile libera Variabili lessicali

FUNZIONI & SCOPE RULES  Gli identificatori dichiarati dentro una funzione (parametri formali inclusi) sono visibili SOLO all'interno della funzione  Gli identificatori dichiarati nel blocco in cui la definizione della funzione è inserita sono visibili ANCHE dentro la funzione (a meno che non siano ridefiniti)

ESEMPIO int trentadue = 32; float fahrToCelsius( float F ){ float temp = 5.0 / 9; return temp * ( F - trentadue ); } Variabile definita nel blocco in cui è inserita la definizione della funzione

VARIABILI LIBERE & COMPONENTI SOFTWARE ATTENZIONE! Le variabili libere:  introducono un accoppiamento fra cliente e servitore  condizionano l’utilizzo della funzione all’esistenza di una definizione “esterna” per la variabile libera  limitano la riutilizzabilità della funzione intesa come componente software.

ESEMPIO int trentadue = 32; float fahrToCelsius( float F ){ float temp = 5.0 / 9; return temp * ( F - trentadue ); } In C, una variabile definita fuori da una funzione si dice variabile globale

ESEMPIO int trentadue = 32; float fahrToCelsius( float F ){ float temp = 5.0 / 9; return temp * ( F - trentadue ); } In C, una variabile definita fuori da una funzione si dice variabile globale In effetti, il suo environment di definizione non coincide con quello di nessuna funzione (neppure con quello del main)

VARIABILI GLOBALI Una variabile globale è definita fuori da qualunque funzione (“a livello esterno”) tempo di vita = intero programma scope = il file in cui è dichiarata (dal punto in cui è scritta in avanti)

ESEMPIO int trentadue = 32; float fahrToCelsius( float F ){ float temp = 5.0 / 9; return temp * ( F - trentadue ); } Definizione (e inizializzazione) di una variabile globale

Anche per le variabile globali si distingue fra dichiarazione e definizione –al solito, la dichiarazione esprime proprietà associate al simbolo, ma non genera un solo byte di codice –la definizione invece implica anche allocazione di memoria VARIABILI: DICHIARAZIONI E DEFINIZIONI

Regola fondamentale di visibilità: –prima dell’uso, una variabile globale deve almeno essere stata dichiarata –Caso particolare: la definizione può fungere anche da dichiarazione VARIABILI: DICHIARAZIONI E DEFINIZIONI

int trentadue = 32; float fahrToCelsius(float); main() { float c = fahrToCelsius(86); } float fahrToCelsius(float f) { return 5.0/9 * (f-trentadue); } ESEMPIO Definizione (e ini- zializzazione) della variabile globale File prova3.c Uso della var.glob.

Come distinguere la dichiarazione da una definizione? –non c’è l’analogo del corpo della funzione.. Si usa la parola chiave extern –int trentadue = 10; è una definizione (con inizializzazione) –extern int trentadue; è una dichiarazione VARIABILI: DICHIARAZIONI E DEFINIZIONI

extern int trentadue; float fahrToCelsius(float f) { return 5.0/9 * (f-trentadue); } main() { float c = fahrToCelsius(86); } int trentadue = 32; ESEMPIO Dichiarazione variabile globale File prova4.c Uso della var.glob. Definizione della variabile globale

Come sempre, una applicazione può contenere –più dichiarazioni per lo stesso simbolo –ma una e una sola definizione di tale simbolo. NB: la dichiarazione non può conte- nere anche una inizializzazione –è solo un avviso, la variabile non è lì! VARIABILI: DICHIARAZIONI E DEFINIZIONI

Una funzione è un componente software che ha un suo environment di definizione e può essere invocato per nome da altre funzioni (in particolare, dal main) Dove scrivere le funzioni? Quali regole pratiche? Quale organizzazione? FUNZIONI come COMPONENTI SW

Per costruire un’applicazione occorre compilare il file (o i file se più d’uno) che contengono il testo del programma (file sorgente) Il risultato sono uno o più file oggetto. collegare i file oggetto l’uno con l’altro e con le librerie di sistema. COSTRUZIONE DI UN’APPLICAZIONE

1) Compilare il file (o i file se più d’uno) che contengono il testo del programma –File sorgente:estensione.c –File oggetto:estensione.o o.obj COMPILAZIONE DI UN’APPLICAZIONE f1.cf1.obj compilatore

1) Compilare il file (o i file se più d’uno) che contengono il testo del programma –File sorgente:estensione.c –File oggetto:estensione.o o.obj COMPILAZIONE DI UN’APPLICAZIONE f1.cf1.obj compilatore Una versione tradotta che però non è autonoma (e, quindi, non è direttamente eseguibile).

2) Collegare il file (o i file) oggetto fra loro e con le librerie di sistema –File oggetto:estensione.o o.obj –File eseguibile:estensione.exe o nessuna COLLEGAMENTO DI UN’APPLICAZIONE prog.exe f1.obj LIBRERIE DI SISTEMA linker Programma eseguibile

Perché tutto questo? il nostro programma non è destinato a funzionare sulla macchina "nuda", ma sulla macchina rivestita dal sistema operativo quindi il nostro programma, per funzionare, deve necessariamente interfacciarsi col sistema operativo stesso. COSTRUZIONE DI UN’APPLICAZIONE

Non solo: alcune istruzioni “complesse” del linguaggio potrebbero essere realizzate in realtà da "mini-programmi" forniti insieme al compi- latore, che li "ingloba" quando occorre. LIBRERIE DI SISTEMA: insieme di componenti software che consen- tono di interfacciarsi col sistema operativo, usare le risorse da esso gestite, e realizzare alcune "istruzioni complesse" del linguaggio COSTRUZIONE DI UN’APPLICAZIONE

Last but not least... una applicazione complessa non può essere sviluppata in un unico file: sarebbe ingestibile! deve necessariamente essere strutturata su più file sorgenti, che devono poter essere compilati separatamente per essere poi fusi insieme alla fine. COSTRUZIONE DI UN’APPLICAZIONE

In passato, la costruzione si faceva “a mano”, attivando compilatore e linker dalla linea di comando del sistema operativo (DOS, Unix,...) C:\PROVA> gcc -c f1.c (genera f1.obj ) C:\PROVA> ld -o prog.exe f1.obj –lc (genera prog.exe ) COSTRUZIONE “MANUALE” Libreria C File oggetto Eseguibile da produrre

Oggi, gli ambienti di lavoro integrati auto- matizzano la procedura:  compilano i file sorgente (se e quando necessario)  invocano il linker per costruire l’eseguibile ma per farlo devono sapere:  quali file sorgente costituiscono l’applicazione  il nome dell’eseguibile da produrre. AMBIENTI INTEGRATI

È da queste esigenze che nasce il concetto di PROGETTO un contenitore concettuale (e fisico) che elenca i file sorgente in cui l’applicazione è strutturata ed eventualmente altre informazioni utili. Oggi, tutti gli ambienti di sviluppo integrati, per qualunque linguaggio, forniscono questo concetto e lo supportano con idonei strumenti. PROGETTI

PROGETTI IN DJGPP/RHide Si sceglie la voce di menù Project  Open Project, e, nella finestra che appare, si sceglie un nome per il nuovo progetto (che sarà anche il nome dell’eseguibile)

PROGETTI IN DJGPP/RHide Si va poi nella Project Window che appare, e si preme sulla tastiera il tasto INS (o si sceglie da menù l’opzione Project  add item )

PROGETTI IN DJGPP/RHide Dalla finestra Add item che appare si selezionano i file sorgente che si vogliono inserire nel progetto.

PROGETTI IN DJGPP/RHide Facendo doppio clic su un nome di file (ad esempio, f1.c ) si apre l’editor per modificarlo.

PROGETTI IN DJGPP/RHide A questo punto:  per compilare, Compile  Compile (ALT+F9) (ricompila solo i file modificati dall’ultima compilazione)  per collegare, Compile  Link

PROGETTI IN DJGPP/RHide A questo punto:  per compilare, Compile  Compile (ALT+F9) (ricompila solo i file modificati dall’ultima compilazione)  per collegare, Compile  Link Oppure le due fasi insieme: Compile  Make (F9)

PROGETTI IN TURBO C Dal sceglie il menù Project  New Project, (oppure l’icona in alto)...

PROGETTI IN TURBO C La finestra che appare richiede varie informazioni. 1) percorso e nome del progetto (per default coincide con il Target Name, cioè col nome dell’eseguibile da produrre)

PROGETTI IN TURBO C 2) il Target Type, cioè il tipo di applicazione da generare: essenziale scegliere EasyWin (non Application ) Turbo C è un ambiente multi-target, cioè può produrre sia applicazioni per Windows (che vanno strutturate in modo particolare), sia applicazioni standard da eseguire in una finestra di Windows emulando una console.

PROGETTI IN TURBO C 3) premendo il tasto Advanced : un nodo iniziale.c nessuna risorsa (né.rc, né.def )

PROGETTI IN TURBO C Si va poi nella finestra Project che appare, e si preme sulla tastiera il tasto INS (o si fa clic nella finestra con il tasto destro e si sceglie la voce Add Node )

PROGETTI IN TURBO C Dalla finestra Add to Project List si selezionano i file da inserire nel progetto.

PROGETTI IN TURBO C Facendo doppio clic su un nome di file (ad esempio, aaa.c ) si apre l’editor per modificarlo.

PROGETTI IN TURBO C A questo punto:  per compilare, Project  Compile (ALT+F9) (ricompila solo i file modificati dall’ultima compilazione)  per collegare, Project  Make all (F9) (fa le due fasi insieme; non si può solo collegare)

Una volta scritto, compilato e collegato il programma (ossia, costruito l’eseguibile) Come si esegue il programma? Come “spiare” quello che fa? Occorre uno strumento che consenta di eseguire il programma passo per passo vedendo le variabili e la loro evoluzione e seguendo le funzioni via via chiamate. ESEGUIRE IL PROGRAMMA

Una volta scritto, compilato e collegato il programma (ossia, costruito l’eseguibile) Come si esegue il programma? Come “spiare” quello che fa? Occorre uno strumento che consenta di eseguire il programma passo per passo vedendo le variabili e la loro evoluzione e seguendo le funzioni via via chiamate. ESEGUIRE IL PROGRAMMA IL DEBUGGER

Sia Rhide sia TURBO C incorporano un debugger con cui eseguire il programma riga per riga –entrando anche dentro alle funzioni chiamate (Run  trace into; F7) (Debug  trace into; F7) –oppure considerando le chiamate di funzione come una singola operazione (Run  step over; F8) (Debug  step over; F8) oppure fino alla riga desiderata (Run  Go to cursor; F4) (F4) ESEGUIRE IL PROGRAMMA

… e con cui inoltre è possibile: controllare istante per istante quanto vale una variabile –Debug  Watch an expression (CTRL+F7) –Debug  Add watch (CTRL+F5) vedere istante per istante le funzioni attive (record di attivazione nello stack) –Debug  Call stack (CTRL+F3) –View  Call stack ESEGUIRE IL PROGRAMMA

UN ESEMPIO COMPLETO: IL FATTORIALE Project: c:\temp\fatt Target Name: fatt Target Type: EasyWin

ESEMPIO: IL FATTORIALE Source node: fatt.c

ESEMPIO: IL FATTORIALE Si scrive il programma, lo si salva, e...

ESEMPIO: IL FATTORIALE … lo si costruisce (F9). Se non ci sono errori...

ESEMPIO: IL FATTORIALE … si può passare a ese- guirlo con il debugger. Premendo F7 ci si posiziona all’inizio del main.

ESEMPIO: IL FATTORIALE Premendo ancora F7 ci si posiziona sulla prima istru- zione, pronti per eseguirla.

ESEMPIO: IL FATTORIALE Volendo, si può mettere sotto osservazione la variabile y, sfruttando l’Add watch. Inoltre, si possono vedere i record di attivazione con il View Call Stack (ora, ovvia- mente, c’è solo il main)

ESEMPIO: IL FATTORIALE Si noti che la variabile y risulta ora indefinita: siamo usciti dallo scope del main! Via via che l’esecuzione pro- segue, il Call Stack mostra la successione dei record di attivazione che si accumulano. Però, possiamo aggiungere ai watch la variabile v, che esiste nello scope di factIter.

ESEMPIO: IL FATTORIALE Si noti che v, come previsto, vale attualmente 6 (che costi- tuisce il risultato) Nel momento di massima espan- sione (che coincide col momento in cui si ha il risultato), il Call Stack mostra ben 5 record attivi.

ESEMPIO: IL FATTORIALE Appena prima che il main termini, y vale finalmente 6. La computazione è completata.

ESEMPIO: IL FATTORIALE Quando il main è terminato, nessuna variabile esiste più Tutto è scomparso.