FUNZIONI... Una funzione permette di  dare un nome a una espressione  rendendola parametrica float f(){ return * sin(0.75); } float f1(int x) { return 2 + x * sin(0.75); }

.. E PROCEDURE Una procedura permette di  dare un nome a una istruzione  rendendola parametrica  non denota un valore, quindi non c’è tipo di ritorno  void void p(int x) { float y = x * sin(0.75); }

PROCEDURE come COMPONENTI SW Una procedura è un componente software che cattura l’idea di “macro-istruzione”  molti possibili parametri, che possono anche essere modificati  nessun “valore di uscita” esplicito

PROCEDURE come SERVITORI Come già una funzione, una procedura è un servitore passivo che serve un cliente per volta che può trasformarsi in cliente invocando se stessa In C, una procedura ha la stessa struttura di una funzione, salvo il tipo di ritorno che è void

RITORNO DA PROCEDURA  L’istruzione return provoca solo la restituzione del controllo al cliente  non è seguita da una espressione da restituire  quindi, non è necessaria se la proce- dura termina “spontaneamente” a fine blocco (cioè al raggiungimento della parentesi graffa di chiusura)

COMUNICAZIONE CLIENTE/SERVITORE Nel caso di una procedura, non esistendo valore di ritorno, cliente e servitore comu- nicano solo: mediante i parametri mediante aree dati globali Il passaggio per valore non basta più: occorre il passaggio per riferimento per poter fare cambiamenti perma- nenti ai dati del cliente.

PASSAGGIO DEI PARAMETRI In generale, un parametro può essere trasferito:  per valore o copia (by value)  si trasferisce il valore del parametro attuale  per riferimento (by reference)  si trasferisce un riferimento al parametro attuale

ESEMPIO Perché il passaggio per valore non basta? Problema: scrivere una procedura che scambi i valori di due variabili intere. A T B Specifica: Dette A e B le due variabili, ci si può appoggiare a una variabile ausiliaria T, e fare una “triangolazione” in tre fasi.

ESEMPIO Supponendo di utilizzare, senza preoccuparsi, il passaggio per valore usato finora, la codifica potrebbe essere espressa come segue: A T B void scambia(int a, int b) { int t; t = a; a = b; b = t; return; /* può essere omessa */ }

ESEMPIO Il cliente invocherebbe quindi la procedura così: A T B main(){ int y = 5, x = 33; scambia(x, y); /* ora dovrebbe essere x=5, y=33... MA NON E’ VERO !! */ } Perché non funziona??

ESEMPIO  La procedura ha effettivamente scambiato i valori di A e B al suo interno  ma questa modifica non si è propagata al cliente, perché sono state scambiate le co- pie locali alla procedura, non gli originali!  al termine della procedura, le sue variabili locali sono state distrutte  nulla è rimasto del lavoro fatto dalla procedura!!

PASSAGGIO PER VALORE clienteservitore x 33 copia a 33 valori (copiati) di x e y Ogni azione fatta su a e b è strettamente locale al servitore y 5 b 5

PASSAGGIO PER VALORE clienteservitore x 33 copia a 5 valori (copiati) di x e y Quindi, a e b possono sì essere scambiati... y 5 b 33 … ma quando il servitore termina, tutto scompare!

PASSAGGIO PER VALORE cliente x e qui non è cambiato niente!!! y 5

PASSAGGIO DEI PARAMETRI IN C Il C adotta sempre il passaggio per valore  è sicuro: le variabili del chiamante e del chiamato sono disaccoppiate  ma non consente di scrivere componenti software il cui scopo sia diverso dal calcolo di una espressione  per superare questo limite occorre il passaggio per riferimento (by reference)

PASSAGGIO PER RIFERIMENTO Il passaggio per riferimento (by reference)  non trasferisce una copia del valore del parametro attuale  ma un riferimento al parametro, in modo da dare al servitore accesso diretto al parametro in possesso del cliente  il servitore, quindi, accede direttamente al dato del cliente e può modificarlo.

PASSAGGIO DEI PARAMETRI IN C Il C non supporta direttamente il passaggio per riferimento  è una grave mancanza  lo fornisce indirettamente solo per alcuni tipi di dati (array)  quando serve occorre quindi costruirselo. Il C++ e Java invece lo forniscono.

PASSAGGIO PER RIFERIMENTO Si trasferisce un riferimento ai parametri attuali (cioè i loro indirizzi) cliente x 33 y 5

PASSAGGIO PER RIFERIMENTO clienteservitore riferimento a  riferimenti a x e y (indirizzi)  x 33 y 5 b   riferimento Ogni azione fatta su a e b in realtà è fatta su x e y nell’environment del cliente

PASSAGGIO PER RIFERIMENTO clienteservitore riferimento a  riferimenti a x e y (indirizzi)  x 33 y 5 b   riferimento Quindi, scambiando a e b...

PASSAGGIO PER RIFERIMENTO clienteservitore riferimento a  riferimenti a x e y (indirizzi)  x 5 y 3 b   riferimento … in realtà si scambiano x e y !

PASSAGGIO PER RIFERIMENTO cliente x 5... e alla fine la modifica permane! y 33

PASSAGGIO PER RIFERIMENTO IN C++ In C++, il passaggio per riferimento si attiva cambiando leggermente la sintassi della dichiarazione dei parametri nel servitore.  Non più:  ma bensì: & Il cliente, invece, non cambia.

L’ESEMPIO RIFORMULATO Quindi: void scambia( int& a, int& b ) { int t; t = a; a = b; b = t; } main(){ int y = 5, x = 33; scambia(x, y); /* ora funziona! */ } Nota: un file sorgente C++ deve avere estensione.cpp

ESEMPIO - RECORD DI ATTIVAZIONE Caso del passaggio per valore:

ESEMPIO - RECORD DI ATTIVAZIONE Caso del passaggio per riferimento (C++):

REALIZZARE IL PASSAGGIO PER RIFERIMENTO IN C  Il C non fornisce direttamente un modo per attivare il passaggio per riferimento, come fa invece il C++  Però, il passaggio per riferimento è praticamente indispensabile  quindi, dobbiamo costruircelo. È possibile costruirlo? E se sì, come?

REALIZZARE IL PASSAGGIO PER RIFERIMENTO IN C  Poiché passare un parametro per riferimen- to comporta la capacità di inserire nei re- cord di attivazione indirizzi di variabili…  … gestire il passaggio per riferimento im- plica la capacità di accedere, direttamente o indirettamente, agli indirizzi delle varia- bili.

REALIZZARE IL PASSAGGIO PER RIFERIMENTO IN C In particolare occorre essere capaci di:  ricavare l’indirizzo di una variabile  dereferenziare un indirizzo di variabile, ossia “recuperare” la variabile dato il suo indirizzo.

REALIZZARE IL PASSAGGIO PER RIFERIMENTO IN C  Nei linguaggi che offrono direttamente il passag- gio per riferimento, questi passi sono effettuati dalla macchina virtuale del linguaggio in modo trasparente all’utente.  L’utente non manipola direttamente gli indirizzi: è la macchina virtuale del linguaggio a farlo per lui. La barriera di astrazione del linguaggio di alto livello viene mantenuta L’utente non conosce e non manipola direttamente alcun dettaglio legato alla macchina sottostante.

REALIZZARE IL PASSAGGIO PER RIFERIMENTO IN C  Se un linguaggio non offre direttamente il passag- gio per riferimento, l’unica possibilità per realiz- zarlo è manipolare direttamente gli indirizzi delle variabili.  Occorre potersi “appoggiare alla macchina sotto- stante” per realizzare direttamente su essa ciò che manca nel linguaggio. La barriera di astrazione del linguaggio di alto livello viene perforata!! L’utente deve conoscere e manipolare entità che sono proprie non del linguaggio ad alto livello, ma della macchina sottostante!

REALIZZARE IL PASSAGGIO PER RIFERIMENTO IN C Questo significa che il linguaggio ad alto livello considerato manca di qualcosa. Questa mancanza:  è definitiva, se il linguaggio non consente comunque di accedere alla macchina sottostante  è rimediabile, se il linguaggio è conscio di questa sua mancanza e prevede perciò un modo per “perforare” la barriera di astrazione.

INDIRIZZO E DEREFERENCING Il C offre a tale scopo due operatori, che consentono di:  ricavare l’indirizzo di una variabile operatore estrazione di indirizzo &  dereferenziare un indirizzo di variabile operatore di dereferenziamento *

INDIRIZZO E DEREFERENCING Se x è una variabile, &x denota l’indirizzo in memoria di tale variabile: &x   Se  è l’indirizzo di una variabile, *  denota tale variabile: x  * 

INDIRIZZO E DEREFERENCING &x   x  *   x Livello di astrazione della macchina base Livello di astrazione del linguaggio di alto livello

PUNTATORI Un puntatore è il costrutto linguistico introdotto dal C (e da molti altri linguaggi) come forma di accesso alla macchina sottostante. Un “tipo puntatore a T” è un tipo che denota l’indirizzo di memoria di una variabile di tipo T. Un PUNTATORE a T è una variabile di “tipo puntatore a T” che può contenere l’indirizzo di una variabile di tipo T.

PUNTATORI Definizione di una variabile puntatore: * ; Esempi: int *p ; Queste tre forme sono equivalenti, e definiscono p come “puntatore a intero”

RICOSTRUIRE IL PASSAGGIO PER RIFERIMENTO IN C In C++ il cliente non deve fare esplicita- mente nulla: è il servitore che specifica che i parametri devono passare per riferimento. Volendo ricostruire tutto ciò in C: –il cliente deve passare esplicitamente gli indirizzi –il servitore deve prevedere esplicitamente dei puntatori come parametri formali

IL SOLITO ESEMPIO void scambia( int* a, int* b ) { int t; t = *a ; *a = *b ; *b = t; } main(){ int y = 5, x = 33; scambia( &x, &y ); } Il cliente deve ricavare esplicitamente gli indirizzi di x e y, per passarli.

IL SOLITO ESEMPIO void scambia( int* a, int* b ) { int t; t = *a ; *a = *b ; *b = t; } main(){ int y = 5, x = 33; scambia( &x, &y ); } Il servitore deve prevedere esplicitamente dei puntatori Cambia, da entrambi i lati, il contratto di comunicazione.

OSSERVAZIONE Quando un puntatore è usato per realiz- zare il passaggio per riferimento, la funzione non dovrebbe mai alterare il valore del puntatore. Quindi, se a e b sono due puntatori: *a = *b SI a = b NO

OSSERVAZIONE Quando un puntatore è usato per realiz- zare il passaggio per riferimento, la funzione non dovrebbe mai alterare il valore del puntatore. NOTA: questo non significa che in generale una fun- zione non debba o possa modificare un puntatore: semplicemente, non è opportuno che lo faccia se esso realizza un passaggio per riferimento

PUNTATORI Un puntatore è una variabile destinata a contenere l’indirizzo di un’altra variabile Vincolo di tipo: un puntatore a T può contenere solo l’indirizzo di variabili di tipo T. Esempio: int x = 8; int* p; p = &x; /* OK */

PUNTATORI int x = 8; int* p; p = &x; /* OK */ Da questo momento, *p e x sono due modi alternativi per denotare la stessa variabile  x p   8

PUNTATORI int x = 8; int* p = &x; *p = 31; x--; Il valore di *p, alias x, è ora 30. Il valore di p, invece, rimane immutato.  x p  

PUNTATORI In questo momento, p punta a x, e perciò *p è un alias per x. Ma un puntatore non è legato per sempre alla stessa variabile: può puntare altrove. int x = 8, y = 66; int *p = &x; (*p)++;/* incrementa x */ p = &y;/* ora p punta a y */ (*p)--;/* decrementa y */

PUNTATORI In questo momento, p punta a x, e perciò *p è un alias per x. Ma un puntatore non è legato per sempre alla stessa variabile: può puntare altrove. int x = 8, y = 66; int *p = &x; (*p)++;/* incrementa x */ p = &y;/* ora p punta a y */ (*p)--;/* decrementa y */ Le parentesi intorno a (*p) sono necessarie per modi- ficare l’oggetto puntato da p e non p stesso.

PUNTATORI Un puntatore a T può contenere solo l’in- dirizzo di variabili di tipo T: puntatori a tipi diversi sono incompatibili tra loro. Esempio: int x=8,*p; float *q; p = &x; /* OK */ q = p; /* NO! */ MOTIVO: il tipo del puntatore serve per dedurre il tipo dell’oggetto puntato, che è una informazione indispensabile per effettuare il dereferenziamento.

PUNTATORI Forzare un assegnamento fra puntatori a tipi diversi è possibile mediante un cast esplici- to, ma è molto pericoloso! int x=8,*p; float *q; q = (float*)&x; ATTENZIONE!! È facile scriverlo… … ma quasi sempre si ottengono solo guai! Aggirare il type system non è (quasi) mai una buona idea!!

IL SOLITO ESEMPIO void scambia(int* pa, int* pb) { int t; t = *pa ; *pa = *pb ; *pb = t; } main(){ int y = 5, x = 33; int *py = &y, *px = &x; scambia( px, py ); } Variazione sul tema: gli indirizzi di x e y sono posti in due puntatori px e py prima di passarli.

IL SOLITO ESEMPIO Osserva: pa e pb sono copie di px e py! Il C passa davvero tutto sempre e solo per valore!

ESERCIZIO Scrivere una procedura che, dato un carattere C, lo trasformi in maiuscolo. Specifica di I° livello: void maiuscolo(char *pc); restituisce il maiuscolo di C Specifica di II° livello: Se *pc non è una lettera minuscola, restituiscilo tale e quale. Altrimenti, per calcolare il corrispondente maiu- scolo, sfrutta l’ ordinamento della codifica dei caratteri: – ogni carattere è associato a un intero – le lettere da ‘A’ a ‘Z’ sono in sequenza – le lettere da ‘a’ a ‘z’ sono in sequenza

ESERCIZIO void maiuscolo(char *pc) { if (*pc 'z') return; else *pc –= 'a' - 'A'; } o anche: void maiuscolo(char *pc) { if (*pc>='a' && *pc<='z') *pc += 'A' - 'a'; } Cosa succede se si dimentica un asterisco?

COMUNICAZIONE TRAMITE ENVIRONMENT GLOBALE Una procedura può anche comunicare con il suo cliente mediante aree dati globali: un esempio sono le variabili globali del C. Esempio: Divisione intera x/y con calcolo di quoziente e resto. occorre calcolare due valori che supponiamo di mettere in due variabili globali.

COMUNICAZIONE TRAMITE ENVIRONMENT GLOBALE int quoziente, int resto; void dividi(int x, int y) { resto = x % y; quoziente = x/y; } main(){ dividi(33, 6); } Il risultato è nelle variabili globali quoziente e resto : il cliente deve andar- selo a prendere! Soprattutto, niente indica che sia là: bisogna saperlo.

L’ENVIRONMENT GLOBALE Le variabili globali in C: sono allocate nell’area dati globale esistono già prima della chiamata del main sono inizializzate automaticamente a 0 salvo diversa indicazione (opportuna!) possono essere nascoste in una funzione da una variabile locale omonima sono visibili, previa dichiarazione extern, in tutti i file dell’applicazione

L’ENVIRONMENT GLOBALE Il fatto che le variabili globali in C siano visi- bili, previa dichiarazione extern, in tutti i file dell’applicazione pone dei problemi di prote- zione. Potrebbe essere utile avere variabili globali permanenti come tempo di vita ma protette, nel senso che solo una parte dell’applicazione possa accedervi.

VARIABILI STATICHE In C, una variabile può essere dichiarata static. In questo modo, essa: è permanente come tempo di vita ed è protetta, in quanto è visibile solo entro il suo scope di definizione. Nel caso di una variabile globale, ogni tentativo di accedervi da altri file, tramite dichiarazioni extern, sarà stroncato dal compilatore.

ESEMPIO static int cont = 3; int nextValue(){ return cont++; } La variabile cont è inaccessibile fuori da questo file (il suo scope di definizione); l’unico modo di accedervi è tramite la funzione nextValue se un altro file definisse un’altra variabile globale cont, non ci sarebbe comunque collisione, perché la prima esternamente “non esiste”.

VARIABILI STATICHE Una variabile statica può essere definita anche dentro a una funzione. Così: è comunque protetta, in quanto visibile solo dentro alla funzione (come ogni variabile locale) ma è anche permanente, in quanto il suo tempo di vita diventa quello dell’intero programma. È un mezzo per costruire componenti (fun- zioni) dotati di stato.

ESEMPIO int nextPrime(void) { static lastprime = 0; if (lastprime>=0 && lastprime<=2) return ++lastprime; else { do lastprime += 2; while (!isPrime(lastprime)); return lastprime; } } Questa funzione restituisce a ogni invocazione il suc- cessivo numero primo. È un componente dotato di stato: chiamato più volte, dà ogni volta una risposta diversa

VARIABILI STATICHE Quindi, la parola chiave static ha sempre e comunque due effetti –rende l’oggetto permanente –rende l’oggetto protetto (invisibile fuori dal suo scope di definizione) ma se ne vede sempre uno solo per volta –una variabile definita in una funzione, che è comunque protetta, viene resa permanente –una variabile globale, già di per sé permanente, viene resa protetta.

FUNZIONI STATICHE Nel secondo significato (protezione e nascondimento), la parola chiave static può qualificare anche una funzione. –rende la funzione protetta (invisibile fuori dal file di definizione) –può servire per funzioni “a uso interno”, non destinate a essere invocate da altri static int f(...) {... }