3. Il Binding. 3.1 Le variabili

Transcript

1 3. Il Binding I programmi sono composti di entità come variabili, routines e istruzioni. Ogni entità possiede certe proprietà chiamate attributi. Per esempio, una variabile ha un nome, un tipo, un area di memoria riservata per la memorizzazione del proprio valore; una routine ha un nome, dei parametri formali di un certo tipo, delle convenzioni sul passaggio dei parametri; un istruzione ha delle azioni associate. I valori degli attributi devono essere specificati prima che l entità possa essere usata. Specificare il valore di un attributo è un azione detta binding. Per ogni entità, le informazioni sugli attributi sono contenute in un apposito record detto descrittore. Il binding è un concetto fondamentale nella definizione della semantica di un linguaggio di programmazione. I linguaggi di programmazione si differenziano nel numero di entità che essi possono manipolare, nel numero di attributi associati ad ogni entità, nel momento in cui ha luogo il binding (binding time) e nella stabilità del binding (cioè, se una volta stabilito il binding possa essere modificato). Ci sono quattro momenti in cui il binding può avere luogo. Essi sono: Binding durante la definizione del linguaggio. Nella maggior parte dei linguaggi il tipo intero è associato alla sua controparte matematica, con tutte le operazioni algebriche che lo caratterizzano, già all atto della definizione del linguaggio. Binding durante l implementazione del linguaggio. Consideriamo sempre il binding del tipo intero. Uno degli attributi di un tipo di dato è lo spazio in memoria da riservare per la sua rappresentazione. Varie implementazioni dello stesso linguaggio posso decidere di utilizzare 16, 32 o 64 bit. Binding durante la traduzione del programma. Nel linguaggio Pascal, ad esempio, il tipo integer è predefinito, ma nulla vieta al programmatore di ridefinirlo. In questo caso quindi, il binding del tipo intero avviene sì durante la definizione e l implementazione del linguaggio, ma esso può essere modificato all atto della traduzione del programma. Binding durante l esecuzione del programma. Vi sono linguaggi di programmazione che non richiedono che il tipo di una variabile venga definito a priori, in questo caso il binding della variabile con il suo tipo viene effettuato solo durante l esecuzione del programma e può subire vari cambiamenti durante l esecuzione. Quando il binding viene stabilito prima dell esecuzione del programma ed è, per questo, di solito non modificabile, si dice che è statico, mentre quando esso avviene a tempo di esecuzione si dice dinamico. 3.1 Le variabili I calcolatori tradizionali si basano sull utilizzo di una memoria principale formata da celle elementari ognuna delle quali è identificata da un indirizzo. Il contenuto di una cella è la rappresentazione codificata di un valore. Un valore è un astrazione matematica; la sua rappresentazione codificata in una cella di memoria può essere letta e modificata durante l esecuzione di un programma. La modifica consiste nel sostituire la codifica corrente con un altra. I linguaggi di programmazione basati sul paradigma imperativo possono essere visti come un astrazione, a vari livelli, del comportamento dei calcolatori tradizionali. In particolare, essi introducono la nozione di variabile come un astrazione della nozione di cella di memoria, il nome 1

2 di una variabile come un astrazione dell indirizzo di memoria e l istruzione di assegnamento come un astrazione della modifica del valore contenuto in una cella di memoria. Formalmente, una variabile è una quintupla < nome, scope, tipo, l-value, r-value >, dove nome è una stringa di caratteri usata per rappresentare la variabile all interno delle istruzioni; scope rappresenta la porzione di programma in cui la variabile può essere usata; tipo è il tipo di dato associato alla variabile; l-value è la porzione di memoria riservata alla variabile; r-value è il valore codificato memorizzato nell area di memoria riservata alla variabile Nome e scope Il nome di una variabile viene introdotto di solito attraverso un istruzione speciale, detta dichiarazione e lo scope della variabile si estende normalmente dal punto in cui avviene la dichiarazione a un certo altro punto la cui specifica dipende dal linguaggio. Si dice di solito che una variabile è visibile all interno del suo scope mentre è invisibile al suo esterno. Linguaggi di programmazione diversi adottano regole diverse per eseguire il binding dello scope di una variabile. Illustriamo queste differenze con alcuni esempi. #include <stdio.h> main() int x,y; scanf( %d %d,&x,&y); int temp; temp=x; x=y; y=temp; printf( %d %d,x,y); In questo programma C la dichiarazione di x e y le rende visibili all interno dell intero programma. Il programma contiene un blocco interno che raggruppa una dichiarazione e alcune istruzioni. La dichiarazione di temp la rende visibile soltanto all interno del blocco in cui essa è effettuata. Ciò significa che sarebbe un errore utilizzare temp all interno dell istruzione printf. Sempre nell esempio in questione, se nel blocco interno aggiungessimo la dichiarazione di una variabile locale x, la variabile globale x definita nel main diventerebbe invisibile all interno del blocco poiché mascherata dalla dichiarazione locale con lo stesso nome. Essa torna ad essere visibile non appena il flusso del programma esce dal blocco interno. Il binding di una variabile al suo scope può avvenire sia staticamente che dinamicamente. Il binding statico dello scope avviene sulla base della struttura lessicale del programma, cioè ogni riferimento ad una variabile viene staticamente associato ad una dichiarazione semplicemente esaminando il testo del programma senza eseguirlo. Questa soluzione è quella maggiormente usata. Il binding dinamico dello scope avviene sulla base di una particolare esecuzione del programma. Tipicamente ogni dichiarazione di variabile estende i suoi effetti su tutte le istruzioni successive finché non si 2

3 incontra una nuova dichiarazione della stessa variabile durante l esecuzione. Illustriamo il funzionamento dello scoping dinamico per mezzo di un esempio. /* blocco A */ int x; /* blocco B */ int x; /* blocco C */ x = ; Se il linguaggio segue la regola dello scoping dinamico, un esecuzione del blocco A seguita dal blocco C fa sì che la variabile x nell assegnamento del blocco C sia riferita a quella dichiarata nel blocco A. Un esecuzione del blocco B seguita dal blocco C, invece, fa sì che la variabile x nell assegnamento del blocco C sia riferita a quella dichiarata nel blocco B. La regola dello scoping dinamico è molto semplice e facile da implementare, ma ha un grosso svantaggio in termini di disciplina di programmazione ed efficienza dell implementazione. I programmi diventano difficili da leggere perché l identità di una variabile è determinata di volta in volta sulla base di una particolare esecuzione e quindi non può essere stabilita a priori Tipo Il tipo di una variabile è definito come l insieme dei valori che possono essere associati alla variabile e delle operazioni che possono essere usate per creare, accedere e modificare tali valori. Una variabile di un dato tipo è detta istanza del tipo. Quando un linguaggio viene definito, certi tipi sono direttamente associati a certe classi di valori con le relative operazioni. Ad esempio il tipo integer e gli operatori relativi sono associati alla propria controparte matematica. I valori e le operazioni sono associati ad una certa rappresentazione sulla macchina quando il linguaggio è implementato. Quest ultimo tipo di binding può restringere l insieme dei valori che possono essere rappresentati sulla base di quanto spazio è riservato in memoria per il tipo in questione. In alcuni linguaggi, il programmatore può definire nuovi tipi per mezzo di una dichiarazione di tipo. Per esempio, in Pascal si può scrivere type vector = array[1..10] of integer; 3

4 Questa dichiarazione stabilisce un binding, a tempo di traduzione, tra il tipo vector e la sua implementazione, cioè un array di 10 elementi interi. Come conseguenza di questo binding, il tipo vector eredita tutte le operazioni che caratterizzano il tipo array sulla base del quale esso è definito. Alcuni linguaggi supportano la definizione di veri e propri tipi definiti dall utente permettendo di definire sia l insieme di valori rappresentati sia le operazioni applicabili su ogni sua istanza. Vedremo in seguito come questo meccanismo è la struttura portante su cui si basano i linguaggi orientati agli oggetti. La maggior parte dei linguaggi effettua il binding delle variabili con il loro tipo a tempo di traduzione e il binding non può essere cambiato durante l esecuzione. Questa soluzione è chiamata typing statico. In questi linguaggi, il binding tra variabile e tipo è specificato dalla dichiarazione di variabile. Per esempio, in Pascal possiamo scrivere: var x,y : integer; var c : character; Dichiarando che una variabile appartiene ad un determinato tipo, si fa in modo che le variabili siano protette automaticamente dall applicazione di operazioni illegali. Nel nostro esempio, il compilatore è in grado di individuare l occorrenza di assegnamenti illegali come: x : = c; y : = not y; poiché essi violano le dichiarazioni precedentemente effettuate. La possibilità di eseguire dei controlli prima che il programma sia eseguito (type checking statico) contribuisce ad anticipare l individuazione degli errori e facilita la lettura dei programmi. In alcuni linguaggi (come il BASIC) la prima occorrenza di una nuova variabile è considerata anche una dichiarazione implicita. Il vantaggio dell utilizzazione delle dichiarazioni esplicite rispetto a questo metodo sta nella maggior chiarezza e leggibilità del programma poiché problemi come gli errori di battitura nel nome di una variabile possono essere individuati a tempo di traduzione. Per esempio, in BASIC la situazione in cui si abbia una dichiarazione implicita di una variabile ALPHA = 1 seguita poi da un istruzione ALPA = ALPHA + 1, contenente un evidente errore di battitura, non sarebbe individuata come errore. Bensì ALPA viene interpretata come una nuova variabile dichiarata implicitamente. Va comunque notato come le dichiarazioni implicite o esplicite di una variabile non differiscono dal punto di vista semantico. Entrambe eseguono il binding del tipo a tempo di traduzione, l unica differenza è che nella dichiarazione esplicita si richiede al programmatore di specificare il tipo della variabile utilizzata, mentre in quella implicita il traduttore lo determina automaticamente all atto della prima istanziazione della variabile. Il typing dinamico consiste nell effettuare il binding delle variabili con il loro tipo soltanto a tempo di esecuzione. Le variabili sottoposte a typing dinamico vengono dette variabili polimorfiche. Secondo questa regola il binding viene eseguito implicitamente con appena un valore viene assegnato alla variabile. In generale, il typing dinamico impedisce che si possa effettuare type checking statico: poiché il tipo di una variabile non è noto a priori risulta impossibile controllare se si verificano violazioni sul tipo prima che il programma sia eseguito. In questo caso, tali violazioni possono essere scoperte soltanto a tempo di esecuzione attraverso il type checking dinamico. Per poter eseguire type checking dinamico, le informazioni relative al tipo dinamico di una variabile devono essere memorizzate nel descrittore per tutto il tempo di esecuzione, mentre per i linguaggi che adottano il typing statico i descrittori sono necessari soltanto durante la traduzione. 4

5 3.1.3 l-value L l-value di una variabile è l area di memoria ad essa associata durante l esecuzione. Il tempo di vita di una variabile è il lasso di tempo in cui la variabile esiste. L area di memoria è usata per memorizzare l r-value della variabile. Con il termine oggetto si indica la coppia < l-value, r-value >. L azione di riservare dell area di memoria per una variabile, e che quindi stabilisce il binding tra la variabile e il suo l-value, è detta allocazione di memoria. Il tempo di vita va dal momento in cui viene allocata la memoria fino a quando tale memoria non viene liberata (deallocazione di memoria). In alcuni linguaggi, per certe variabili, l allocazione è eseguita prima dell esecuzione mentre la deallocazione avviene soltanto alla terminazione del programma (allocazione statica). In altri linguaggi, l allocazione è eseguita durante l esecuzione (allocazione dinamica) sia automaticamente a seguito di una dichiarazione che direttamente dal programmatore attraverso opportune istruzioni, e la deallocazione avviene anch essa durante l esecuzione (di solito quando si sa che la variabile non verrà più utilizzata) r-value L r-value di una variabile è il valore codificato memorizzato nell area di memoria associata ad una variabile (cioè il suo l-value). La rappresentazione codificata è interpretata a seconda del tipo della variabile. Per esempio, una certa sequenza di bit sarà interpretata come un intero se il tipo è intero, mentre sarà interpretata come una stringa se il tipo è un array di caratteri. Gli l-value e r-value delle variabili sono i concetti principali legati all esecuzione di un programma. Le istruzioni accedono alle variabili attraverso il loro l-value e modificano eventualmente il loro r-value. I termini l-value e r-value derivano dalla struttura convenzionale delle istruzioni di assegnamento, come x = y. La variabile che appare a sinistra indica una locazione, mentre quella che appare a destra indica il contenuto di una locazione, ovvero un valore. D ora in poi, quando non ci sarà ambiguità di notazione, useremo semplicemente il termine valore per indicare l r-value di una variabile. Il binding tra una variabile e il suo valore è ovviamente dinamico; il binding è stabilito dall operazione di assegnamento. Un assegnamento del tipo x = y; fa sì che l r-value di y sia copiato nell area di memoria definito dall l-value di x, cioè l r-value di x è modificato. Di solito è anche possibile fare in modo che il binding di una variabile con il proprio valore non sia più modificabile una volta stabilito. In questo caso siamo di fronte alla definizione di una costante da parte del programmatore. Il binding del valore di una costante può avvenire sia a tempo di traduzione (come, ad esempio, nel Pascal) che a tempo di esecuzione (come avviene nel C dove una costante può essere definita utilizzando un espressione contenete anche delle variabili). Infine, un classico problema che riguarda il binding tra una variabile e il suo valore è il seguente: qual è il valore di una variabile immediatamente dopo la sua creazione? Alcuni linguaggi richiedono che il programmatore specifichi un valore iniziale all atto della dichiarazione della variabile, altri linguaggi forniscono un inizializzazione di default (per esempio, gli interi sono inizializzati a 0, i caratteri sono inizializzati al carattere blank e così via), altri semplicemente ignorano il problema considerando come valore iniziale della variabile la stringa di bit attualmente memorizzata nel suo l-value, altri infine bloccano l utilizzo di una variabile non inizializzata Variabili senza nome e puntatori Alcuni linguaggi consentono l accesso a una variabile attraverso l r-value di un altra variabile. Un tale r-value è chiamato puntatore alla variabile. Le variabili alle quali si accede attraverso un puntatore sono dette senza nome. Infatti, l unico modo per accedere a queste variabile è attraverso 5

6 una qualche variabile con nome. La variabile senza nome può essere puntata direttamente da una variabile con nome, oppure può essere puntata da un altra variabile senza nome che, a sua volta, è puntata da una variabile con nome. In generale, si può accedere ad un oggetto attraverso una catena di puntatori (chiamato cammino di accesso) di lunghezza arbitraria. Se A = < A_nome, A_scope, A_tipo, A_l-value, A_r-value > è una variabile con nome, l oggetto < A_l-value, A_r-value > è direttamente accessibile attraverso il nome A_nome all interno di A_scope seguendo un cammino di accesso di lunghezza 0. Se B = < --, --, --, B_l-value, B_r-value >, dove -- sta per un valore non specificato, è una variabile e B_l-value = A_r-value, l oggetto < B_l-value, B_r-value > è indirettamente accessibile attraverso il nome A_nome all interno di A_scope seguendo un cammino di accesso di lunghezza 1. Allo stesso modo, si può definire il concetto di oggetto accessibile indirettamente attraverso una variabile con nome seguendo un cammino di accesso di qualsiasi lunghezza. Per esempio, in Pascal possiamo definire un tipo PI come puntatore a un intero: type PI = ^ integer; Possiamo quindi allocare una variabile intera senza nome e puntarla attraverso una variabile pxi di tipo PI: var pxi : PI; new(pxi); Per poter accedere all oggetto senza nome puntato da pxi è necessario usare l operatore ^ che, applicato ad una variabile puntatore, restituisce il suo r-value, cioè l l-value dell oggetto desiderato. Per esempio, possiamo porre a zero la nostra variabile senza nome scrivendo: pxi ^ : = 0; Si può accedere alla variabile senza nome anche tramite un cammino di accesso di lunghezza 2 nel seguente modo: type PPI = ^ PI; var ppxi : PPI; new(ppxi); ppxi ^ : = pxi; Qui l r-value di ppxi è l l-value di una variabile senza nome il cui r-value è l l-value di una variabile senza nome il cui r-value è 0. La situazione ottenuta è descritta nella seguente figura. ppxi 0 pxi 6

7 Il Pascal consente di puntare solo variabili senza nome. Altri linguaggi come il C consentono di puntare anche variabili con nome. Ad esempio, il codice C int x = 5; int* px; px = &x; crea un oggetto intero, il cui r-value è 5, direttamente accessibile attraverso una variabile di nome x e indirettamente accessibile attraverso px, dichiarato come un puntatore a interi. Questo è ottenuto assegnando a px l l-value di x ottenuto attraverso l operatore &. L accesso indiretto a x è ottenuto utilizzando l operatore *. L istruzione *px = 0; assegna il valore 0 alla variabile puntata da px. In questo caso quindi la modifica si ripercuote anche sulla variabile x che assumerà il valore 0. In questo caso, infatti, l oggetto < x_l-value, x_r-value > è condiviso da x e da px poiché entrambi dispongono di un cammino di accesso ad esso. La condivisione di un oggetto può essere utile a volte per migliorare l efficienza di un programma, ma è comunque una cattiva pratica di programmazione e va usata con attenzione dato che il valore di una variabile può essere modificato senza che il suo nome venga utilizzato. 3.2 Le routine I linguaggi di programmazione consentono di strutturare un programma come composizione di un certo numero di unità chiamate routine. In questo paragrafo analizzeremo le principali caratteristiche sintattiche e semantiche delle routine e, in particolare, i meccanismi che controllano il flusso di esecuzione tra le varie routine e la determinazione del binding all atto dell esecuzione di una routine. Secondo uno standard più o meno consolidato, le routine sono generalmente di due tipi: procedure e funzioni. Le funzioni ritornano un valore al termine della loro esecuzione; le procedure no. Riportiamo un esempio di funzione scritta nel linguaggio C. int sum(int n) int i,s; s = 0; for (i = 0; i <= n; i++) s = s + i; return s; Così come le variabili, anche le routine hanno nome, scope, tipo, l-value e r-value. Il nome di una routine è introdotto nel programma per mezzo di una dichiarazione di routine. Lo scope si estende generalmente dal punto di dichiarazione a qualche punto di chiusura determinato staticamente o dinamicamente a seconda del linguaggio. Ad esempio, nel linguaggio C lo scope di una funzione si estende per tutto il file in cui avviene la dichiarazione. Una routine viene eseguita a seguito di una chiamata nella quale vengono specificati il nome della routine e i parametri su cui essa deve andare ad operare. Poiché una routine è attivata da una 7

8 chiamata, l istruzione di chiamata deve trovarsi all interno dello scope della routine. Oltre ad avere il loro proprio scope, le routine definiscono anche uno scope per le dichiarazioni contenute al proprio interno. Queste dichiarazioni locali sono visibili soltanto all interno della routine. In base alle regole di scoping del linguaggio, le routine possono fare riferimento anche a oggetti (variabili o altre routine) non locali oltre e quelle dichiarate localmente. Oggetti non locali che risultino essere visibili ad ogni unità del programma sono chiamate oggetti globali. L intestazione di una routine definisce il nome della routine, il tipo dei suoi parametri e il tipo del valore eventualmente ritornato. Brevemente, l intestazione di una routine definisce il tipo della routine. Nell esempio sopra il tipo di sum è routine con un parametro intero che ritorna un intero. Il tipo di una routine può essere definito precisamente attraverso il concetto di segnatura. La segnatura specifica i tipi dei parametri e il tipo eventualmente ritornato. Una routine fun con parametri in ingresso T1, T2,, Tn e valore ritornato di tipo R, può essere specificata dalla seguente segnatura: fun : T1 x T2 x x Tn R La chiamata di una routine è di tipo corretto se è conforme al tipo della routine. Ad esempio la chiamata della funzione sum attraverso l istruzione i = sum(5); risulta corretta, mentre quella effettuata tramite l istruzione i = sum(5.3); è sbagliata. L l-value di una routine è un riferimento all area di memoria in cui è memorizzato il corpo della routine (cioè l insieme di istruzioni che la definiscono). L attivazione di una routine ne causa l esecuzione del corpo che costituisce l r-value della routine. Normalmente, il binding di una routine con il proprio r-value avviene a tempo di traduzione. Alcuni linguaggi prevedono l uso di puntatori a routine, il che fornisce un metodo per ottenere l l-value di una routine che può essere assegnato come r-value di un puntatore. Ad esempio, la seguente dichiarazione in C crea un puntatore a un funzione con un parametro intero che ritorna un intero: La seguente istruzione int(*ps)(int); ps = & sum; fa puntare ps all l-value della funzione sum precedentemente definita. Una chiamata a sum può essere effettuata attraverso ps nel seguente modo: int i = (*ps)(5); L uso dei puntatori a routine fornisce la possibilità di chiamare diverse routine ogni volta che uno stesso puntatore viene valutato. Questo fornisce un modo per ottenere un binding dinamico. Alcuni linguaggi distinguono tra dichiarazione e definizione di una routine. La dichiarazione di una routine ne introduce l intestazione senza specificarne il corpo. Il nome risulta visibile dal punto della dichiarazione fino alla fine dello scope. La definizione, invece, specifica sia l intestazione che il corpo. Questa distinzione consente di implementare la mutua ricorsione tra routine, come illustrato nel codice seguente: 8

9 int A(int x, int y); float B(int z) int w,u ; w = A(z,u) ; int A(int x, int y) float t ; t = B(x) ; Quando si effettua una chiamata di routine, questa viene eseguita sulla base dei valori associati ai parametri. La rappresentazione di una routine durante l esecuzione è detta istanza della routine. Un istanza di routine è composta da un segmento di codice e un record di attivazione. Il segmento di codice, il cui contenuto è fissato, contiene le istruzioni che definiscono la routine. Il contenuto del record di attivazione è, invece, variabile. Esso contiene le informazioni necessarie per eseguire la routine come, ad esempio, gli oggetti associati alle variabili locali della particolare istanza di routine. La posizione relativa di un oggetto nel record di attivazione è detta offset. Per far sì che la routine sia in grado di restituire il controllo alla porzione di programma in cui è stata effettuata la chiamata, un puntatore di ritorno è salvato nel record di attivazione all atto della chiamata. L ambiente di riferimento dell istanza U di una routine consiste nelle variabili locali di U, che sono associate agli oggetti memorizzati nel record di attivazione di U, e nelle variabili non locali di U, che sono associate a oggetti memorizzati nei record di attivazione di altre unità. Gli oggetti locali definiscono l ambiente locale, mentre quelli non locali definiscono l ambiente non locale. La modifica di oggetti associati a variabili non locali da parte di una routine è detta effetto collaterale. Nel caso in cui le routine possano essere attivate ricorsivamente, può avere luogo l attivazione di una nuova unità prima che quella dell unità precedente sia terminata. Tutte le istanze di una stessa unità hanno quindi lo stesso segmento di codice, ma differenti record di attivazione. In presenza di ricorsione, dunque, il binding tra un record di attivazione e il suo segmento di codice deve essere necessariamente dinamico. Quando una routine viene attivata, l istruzione chiamante deve passare i parametri alla routine chiamata. Il passaggio dei parametri consente il trasferimento del flusso dei dati tra le varie unità di un programma. Nella maggior parte dei casi, si possono passare soltanto oggetti. Ci sono però dei linguaggi che permettono anche il passaggio di routine. Il passaggio di parametri e la comunicazione attraverso oggetti non locali sono due modi diversi di ottenere il flusso di informazione tra le unità. L utilizzo del passaggio dei parametri ha indubbiamente molti vantaggi in termini di leggibilità e modificabilità. E necessario distinguere tra parametri formali (quelli che appaiono nell intestazione di una routine) e parametri attuali (quelli che appaiono nella chiamata della routine). La maggior parte dei linguaggi di programmazione usa un metodo posizionale per associare i parametri attuali a quelli formali nelle istruzioni di chiamata di routine. Se l intestazione di una routine è 9

10 routine S(F1, F2,, Fn); e la sua chiamata call S(A1, A2,, An); il metodo posizionale implica che il parametro formale Fi sia associato al parametro attuale Ai. In alcuni casi il numero dei parametri attuali e formali può non essere necessariamente identico. Nel C++ è possibile associare un valore di default ai parametri formali che vengono usati nel caso in cui i corrispondenti parametri attuali non vengano specificati nella chiamata. Ad esempio, data una funzione int distance(int a = 0, int b = 0); la chiamata distance() è equivalente alla chiamata distance(0,0), mentre la chiamata distance(10) è equivalente a distance(10,0). Oltre al metodo posizionale, alcuni linguaggi (come l ADA) consentono un associazione nominale dei parametri. Ad esempio, data una procedura procedure Example(A : T1; B : T2 : = W; C : T3); con parametri formali A, B e C di tipo rispettivamente T1, T2 e T3 e con un valore di default W assegnato a B, assumendo che le variabili X, Y e Z siano rispettivamente di tipo T1, T2 e T3, abbiamo che le seguenti chiamate sono tutte corrette: Example(X,Y,Z); Example(X, C => Z); Example(C => Z, A => X, B => Y); La prima chiamata usa l associazione posizionale. La seconda usa l associazione posizionale per A, B prende il valore di default W mentre C è associato a Z attraverso l associazione nominale. Infine, la terza chiamate usa l associazione nominale per tutti e tre i parametri. A volte succede di dover scrivere delle routine molto simili come nel caso in cui si vuole ordinare sia un array di interi che uno di stringhe. In questo caso sono necessarie due procedure, anche se l algoritmo utilizzato è lo stesso, poiché i tipi dei parametri sono diversi. Alcuni linguaggi offrono la possibilità di definire routine generiche in modo da poter ovviare a questo inconveniente. Le routine generiche sono dette anche templates. Riportiamo, come esempio, un template scritto in C++ che scambia il valore di due oggetti dello stesso tipo, qualunque esso sia: template < class T > void swap(t& a, T& b) T temp = a ; a = b ; b = temp ; 10

11 3.3 Aliasing e overloading Fino ad ora abbiamo implicitamente assunto che ogni nome simbolico utilizzato all interno di un programma indichi una e una sola entità, sulla base delle regole di scoping del linguaggio utilizzato. Non è questa la situazione reale. Consideriamo il seguente codice C: int i,j,k; float a,b,c; i = j + k; a = b + c; In questo esempio, l operatore + nelle due istruzioni di assegnamento denota due entità diverse. Nella prima istruzione esso denota l addizione tra interi, nella seconda quella tra numeri in virgola mobile. Nonostante il nome delle due operazioni sia lo stesso, il binding tra l operatore e la rispettiva operazione è diverso nei due casi e l esatto binding può essere determinato a tempo di traduzione analizzando il tipo degli operandi. Questo esempio può essere generalizzato introducendo il concetto di overloading. Un nome è detto sovraccarico (overloaded) se si riferisce a più di una entità in un dato punto di un programma e se la particolare occorrenza del nome fornisce informazioni sufficienti perché il relativo binding possa essere stabilito univocamente. L aliasing è l opposto dell overloading. Due nomi sono alias se denotano la stessa entità in un dato punto di un programma. Questo concetto è particolarmente rilevante nel caso delle variabili. Due variabili alias condividono lo stesso oggetto nello stesso ambiente di riferimento. Un esempio di può essere ottenuto attraverso il seguente codice C: int x = 0; int *i = &x; int *j = &x; 11