Lllezione 12 Template. Template. Lezione 12

Transcript

1 Lezione 12 Cosa è un Il template è un meccanismo che consente di creare uno schema generico di funzione o di classe, che non fa esplicito riferimento a nessun particolare tipo di dati utile quando si devono implementare più funzioni o classi che si comportano allo stesso modo ma lavorano su dati di tipo diverso Il template consente di progettare solo uno schema generale per implementare una particolare operazione Il compilatore provvede a produrre da questo schema il codice effettivo per implementare l operazione su ogni tipo di dati (predefinito o definito dall utente) /02 1

2 Cosa è un di Funzione Il template di funzione è uno schema di funzione generica, che non fa esplicito riferimento a nessun particolare tipo di dati input consente di progettare un unica funzione per implementare una particolare operazione All interno del codice del programma di sarà una diversa funzione per implementare l operazione su ogni tipo di dati La generazione di tutte le funzioni è a carico del compilatore Il compilatore provvede a produrre da questo schema una diversa funzione per ogni tipo di dati 2 Cosa è un di Classe Il template di classe è uno schema di classe generica, che non fa esplicito riferimento a nessun particolare tipo di dati membro consente di progettare un unica classe per implementare un tipo di dato astratto, indipendente dal tipo di dato contenuto al suo interno All interno del codice del programma ci sarà una diversa classe per implementare il tipo di dato astratto per ogni possibile tipo di dato membro La generazione di tutte le classi e dei suoi metodi è a carico del compilatore Il compilatore provvede a produrre da questo schema una diversa classe per ogni tipo di dato membro /02 2

3 e Overloading L overloading consente di assegnare lo stesso nome a funzioni differenti il programmatore deve scrivere tutte le funzioni semplificazione esclusivamente lessicale (assegna un nome ad ogni operazione logica) Il template è uno schema di funzione che può essere applicato su diversi dati il programmatore deve scrivere una sola funzione tutte le versioni ricavate dallo schema devono avere la stessa implementazione e differire solo per il tipo dei dato su cui operano 4 Schemi di Funzione in C Molti linguaggi di programmazione hanno meccanismi che consentono di scrivere delle funzioni generiche In C è possibile usare le macro per produrre funzioni generiche #define max(a,b) ((a)>(b))? (a) : (b) Le macro effettuano una sostituzione testuale degli argomenti con i valori passati nella chiamata alla macro nessun controllo sui tipi il compilatore non è in grado di supportare il controllo sui tipi /02 3

4 Quando Creare di Funzioni Creare un template di funzioni se si devono usare più versioni della stessa funzione che lavorano su dati di tipo diverso Operano tutte alla stessa maniera ma usano variabili di tipo diverso int max(int, int); // massimo tra due interi char max(char, char); // massimo in un vettore di interi double max(double, double); // massimo tra due double Si possono utilizzare i template di funzioni per creare librerie di funzioni generiche l utente della libreria potrà utilizzare la libreria su qualunque tipo di dati 6 Definizione di un Il template di una funzione deve essere dichiarato o definito prima di essere utilizzato dal programma La definizione (dichiarazione) di un template di funzione è una definizione (dichiarazione) di una funzione parametrizzata T max( T* a, int dim) { \\ max in un array (di ogni tipo) T tmp = a[0]; for( int i = 1; i < dim; i++ ) if( a[i] > tmp ) tmp = a[i]; return tmp; /02 4

5 Parametri del Nella definizione (dichiarazione) di un template si deve specificare la lista dei parametri, tra <> Parametri rispetto ai quali è descritto il comportamento della funzione Un parametro può essere un tipo (parametro di tipo) Preceduto dalle parole class o typename un espressione costante (parametro di valore) Preceduta dal tipo del risultato dell espressione template <class T, int size> T max( T (&a)[size]) { \\ max in un array di dimensione size di tipo T 8 Corretta Definizione di un La parola riservata template e la lista dei parametri del template sono obbligatori Ogni parametro deve essere preceduto dal suo tipo class (typename) tipo predefinito (definito dall utente) Tutti i parametri devono avere nomi distinti Ogni parametro deve comparire nella firma della funzione Il nome del parametro non può essere ridefinito nella funzione /02 5

6 Esempi Dichiarazioni di template <class T, class T> T f(t, T); // ERRORE template <class T, U> void f(t, U); // ERRORE template <class T, typename U> void f(t, U); // CORRETTO template <class T, class U> U f(t, T); // ERRORE T f(t, T) { typedef double T; // ERRORE 10 Inizializzazione di Default dei Parametri del Lo standard C++ supporta l inizializzaione per default dei parametri di un template Valgono le stesse regole per l inizializzazione per default dei parametri di una funzione Non tutti i compilatori supportano questa proprietà I compilatori pre-standard non supportano l inizializzazione per default dei parametri del template /02 6

7 Istanziazione di un Quando il compilatore legge la definizione di un template non alloca nessuna memoria non è in grado di calcolare la dimensione del record di attivazione non sa come implementare la funzione parametrizzata La definizione delle varie istanze di funzioni ricavate dal template (istanziazione del template) avviene solo quando queste funzioni vengono utilizzate Funzione invocata dal programma assegnamento dell indirizzo della funzione ad un puntatore l'istruzione che provoca l'istanziazione è detta punto di istanziazione 12 Istanziazione di un Quando il programma invoca una delle funzioni ricavate dal template il compilatore opera nel seguente modo: 1. sospende la compilazione, 2. recupera la definizione del template, 3. deduce dalla chiamata i tipi ed i valori dei parametri 4. sostituisce ai parametri del template i tipi ed i valori dedotti, 5. definisce la funzione così ottenuta L istanziazione avviene soltanto la prima volta che una funzione viene invocata le chiamate successive sono implementate normalmente /02 7

8 Esempio Istanziazione T max(t*, int); int ai[4] = { 12, 8, 73, 45 ; int main() { int size = sizeof (ai) / sizeof (ai[0]); cout << "massimo di ai è: " << max( ai, size ) << endl; // istanzia max(int*, int) 14 Deduzione degli Argomenti E il processo attraverso il quale il compilatore ricava dagli argomenti della chiamata i tipi ed i valori da attribuire ai parametri del template per ogni prima occorrenza di un parametro del template nella lista dei parametri della funzione, assegna al parametro il tipo del corrispondente argomento della chiamata template <class T, class U> void f(t, U, T); f(0, a, 10); \\ genera f(int, char, int) f(0, a, 3.14); \\ ERRORE tutti gli argomenti parametrizzati devono corrispondere esattamente al tipo assegnato al parametro il tipo del risultato non conta per la deduzione /02 8

9 Algoritmo per Istanziazione Quando il compilatore legge una chiamata ad un template di funzione opera nel seguente modo Controlla che ogni parametro del template compaia compaia come parametro della funzione cerca nella firma la prima occorrenza di ogni parametro del template e gli assegna il tipo o il valore dell'argomento corrispondente controlla che tutte le altre occorrenze del parametro del template corrispondano esattamente (anche con corrispondenze banali) con i corrispondenti argomenti cerca una corrispondenza tra i parametri della funzione non parametrizzati ed i corrispondenti argomenti Se il compilatore non è in grado di dedurre il tipo di un parametro del template segnala un ambiguità 16 Esempio template <typename Type, int size> Type min( Type (&r_array)[size] ) { Type min_val = r_array[0]; for ( int i = 1; i < size; ++i ) if ( r_array[i] < min_val ) return min_val; min_val = r_array[i]; int ia[] = { 10, 7, 14, 3, 25, ia2[5] = { 10, 15, 2, 20, 16, *ptr; double da[6] = { 10.2, 7.1, 14.5, 3.6, 25.4 ; int *ptr = ia; int i = min( ia ); i = min( ia2 ); i = min(ptr); i = min( da ); // istanzia min(int(&)[5]) // invoca la funzione min(int(&)[5] // ERRORE // istanzia min(double(&)[6]) /02 9

10 Istanziazione Esplicita Nell invocare un template di funzione è possibile indicare esplicitamente il valore di un parametro del template il compilatore non esegue l'algoritmo di deduzione ed accetta la scelta del programmatore Utile per risolvere le situazioni di ambiguità T min(t, T); int main() { unsigned int ui = 1024; min(ui, 1024); // ERRORE min<int>(ui, 1024); // istanzia min(int, int) min<unsigned int>(ui, 1024); 18 Tipo del Risultato Parametrizzato Utilizzando l'istanziazione esplicita è possibile parametrizzare anche il tipo del risultato istanziazioni di questo template sono corrette solo se esplicite template <class T1, class T2, class T3> T1 min(t2, T3); per le istanziazioni dei parametri del template valgono le stesse regole dell'inizializzazione dei parametri di funzione per default char c; unsigned int ui; unsigned int ris = min(c, ui); // ERRORE ris = min<unsigned int, char, unsigned int>min(c, ui); ris = min<unsigned int>min(c, ui); /02 10

11 Risoluzione Ambiguità L'istanziazione esplicita può essere usata per eliminare l'ambiguità presente nella chiamata ad una funzione che ha argomenti parametrizzati T f(t); void g(int(*)(int)); void g(double(*)(double)); main() { g(&f); g(&f<int(*)(int)>); // ERRORE 20 Overloading di E possibile creare versioni sovrapposte di template di funzioni diversi template svolgono la stessa operazione logica ma in modi differenti tutte le istanze prodotte dai vari template devono differire tra loro per numero o tipo di argomenti Ogni istanza di un template è una funzione del programma che deve avere una firma che la identifica univocamente /02 11

12 Esempio Overloading di T min(t, T); T min(const T*, int); template <typename T> T min(const vector<t>&); int i = 0, ia[10]; i = min(3, 5); // corrisponde alla prima funzione i = min(ia, 10); // corrisponde alla seconda funzione template <class T, class U> int min(t, U); i = min(3, 5); // ambigua, perché? 22 Specializzazione di Per alcuni tipi di dati la versione generale fornita dal template di funzione può essere scorretta o inefficiente E' possibile definire un eccezione al template Lo schema generale del template viene utilizzato per generare funzioni per tutti i tipi di dati tranne quelli per cui sono specificate le eccezioni Per i tipi che fanno eccezione devono essere definite delle specializzazioni del template si può specializzare un template solo dopo aver dichiarato lo schema generale /02 12

13 Specializzazione Esplicita di La definizione di una specializzazione è una definizione di un template con i parametri istanziati T max(t, T); typedef const char* PCC; template <> PCC max<pcc>(pcc s1, PCC s2) { return(strcmp(s1, s2) > 0? s1 : s2); int main() { const char* p = max("ciao", "mondo"); // chiama la specializzazione e non istanzia il template 24 Utilizzo delle Specializzazioni La dichiarazione di una specializzazione deve precedere la prima chiamata alla funzione al momento della chiamata il compilatore deve sapere che deve usare la specializzazione invece del template La dichiarazione di una specializzazione deve essere inclusa in tutti i file in cui viene utilizzata la specializzazione non è possibile usare in un file la specializzazione e in un altro file istanziare il template conviene inserire la dichiarazione del template e delle sue specializzazioni nello stesso header file /02 13

14 Specializzazione Esplicita di T max(t, T); int main() { int i = max( 10, 5 ); // istanzia max( int, int ); const char *p = max( "ciao", "mondo" ); // istanzia const char* max( const char*, const char* ) cout << "i: " << i << " p: " << p << endl; return 0; typedef const char* PCC; template<> PCC max<pcc>(pcc s1, PCC s2) { // ERRORE, doppia definizione 26 Specializzazione Implicita di Una funzione che abbia la stessa firma di un'istanza del template è una specializzazione implicita sulle chiamate a questa funzione non valgono le regole restrittive della deduzione dei parametri del template la definizione di una specializzazione implicita deve precedere la sua istanziazione T min(t, int); int min(unsigned int,int); int i = min(3u,i); // viene chiamata la funzione ordinaria min /02 14

15 Risoluzione dell Overloading e Istanziazioni Nella risoluzione di un overloading il compilatore può istanziare funzioni da un template anche se non esplicitamente invocate nel creare l'insieme dei candidati istanzia tutte le funzioni che possono essere dedotte dagli argomenti della chiamata la funzione istanziata sarà realmente invocata solo se è la migliore funzione utilizzabile T sum(t, int); double sum(double, double); sum(3.14, 0); // istanzia ed invoca sum(double, int) 28 Risoluzione dell Overloading e Specializzazioni Implicite Se un template ha delle specializzazioni implicite nella lista delle funzioni candidate viene inserita sia la specializzazione che la funzione istanziata dal template la specializzazione è preferita rispetto alla funzione istanziata T min(t, T); int min(int, int); min(3, 2); /* la specializzazione e l'istanza del template sono candidate la specializzazione è invocata */ /02 15

16 Risoluzione dell Overloading e Specializzazioni Esplicite Se un template ha delle specializzazioni esplicite nella lista delle funzioni candidate viene inserita la specializzazione e non la funzione istanziata dal template la specializzazione è una candidata solo se la sua firma può essere dedotta dalla chiamata T min(t, T); template <> double min<double>(double, double); int min(int, int); min(3.14, 2); // no match min(3.14, 2.5); // la specializzazione è candidata 30 Risoluzione di una Chiamata ad una Funzione 1. Costruisce l'insieme delle funzioni candidate funzioni con lo stesso nome della funzione chiamata istanze di template con lo stesso nome della funzione chiamata e che possono essere dedotte dalla chiamata 2. Costruisce l'insieme delle funzioni utilizzabili seleziona le funzioni candidate i cui parametri corrispondono per tipo e numero agli argomenti della chiamata 3. Classifica il tipo di corrispondenza di ogni funzione utilizzabile 4. Seleziona la migliore funzione utilizzabile se ne esiste una sola la chiamata è risolta se ce ne sono più di una la chiamata è ambigua se non ce ne sono la chiamata non è risolta /02 16

17 Esempio T min(t, T); double min(double, double); main() { int i; double d; float f; min(0, i); // due candidate, invoca l'istanza del template per T = int min(3.14, d); // invoca la specializzazione min(0, f); // specializzazione unica candidata char min(char, char); // cosa succede alla terza chiamata? 32 Quando Creare di Classi Un template di classe permette di creare classi contenitore che possono essere utilizzate per contenere qualunque tipo di dati class Coda{ T* vett; ; Si possono utilizzare i template di classi per creare librerie di classi generiche l utente della libreria potrà utilizzare la classe della libreria istanziandola per qualunque tipo di dati /02 17

18 Definizione di un di Classi La definizione (dichiarazione) di un template di classi è strutturata come la definizione di una classe normale contiene lista dei parametri del template i parametri possono essere utilizzati nella definizione class Coda { public: Coda(); ~Coda(); void inserisci( const T& ); T& rimuovi(); bool vuota(); private: ; 34 Definizione Classe Coda class CodaItem { public: friend class Coda<T>; CodaItem(const T&); private: CodaItem<T>* succ; T item; ; class Coda { public: Coda(); ~Coda(); void inserisci( const T& ); T& rimuovi(); bool vuota(); private: CodaItem<T>* testa; CodaItem<T>* coda; ; /02 18

19 Istanziazione di un di Classi Quando il compilatore legge la definizione di un template di classi non alloca memoria Un istanza del template viene creata solo quando il programma definisce una variabile della classe per definire una variabile della classe bisogna specificare tutti i valori da assegnare ai parametri del template La definizione di un puntatore o un riferimento non istanzia il template Coda<int> qi; Coda<string> qs; Coda<double>* pqd; Coda q; // non istanzia il template // ERRORE 36 Istanziazione di un di Classi L istanziazione di un template può essere utilizzato come specificatore di tipo Non è possibile far riferimento al template della classe al di fuori dello scope del template /02 19

20 Punto di Istanziazione di un di Classi Il punto di istanziazione di un template è il momento in cui viene generata la classe Definizione di una variabile Dereferenziazione di un puntatore o di un riferimento Nel punto di istanziazione del template deve essere visibile la definizione del template Nel C++ pre-standard dovevano essere visibili anche le definizioni dei metodi La definizione di una classe va inserita in un file di intestazione mentre le definizioni dei suoi metodi vanno inseriti in un file di implementazione Ogni file in cui si istanzia il template include la definizione della classe 38 Metodi di di Classi I metodi di un template di classi sono template di funzioni Possono essere definiti inline all interno della definizione del template o esterni alla definizione class Coda { public: Coda() : testa(0), coda(0) {; ~Coda(); void inserisci( const T& ); T& rimuovi(); bool vuota() { return front == 0; private: CodaItem<T>* testa; CodaItem<T>* coda; ; /02 20

21 Metodi di di Classi Coda<T>::~Coda() { while(!vuota() ) rimuovi(); void Coda<T>::inserisci(const T& val) { CodaItem<T> *pt = new CodaItem<T>(val); if(vuota()) testa = coda = pt; else { coda->succ = pt; coda = pt; 40 Metodi di di Classi T& Coda<T>::rimuovi() { if(vuota()) { cerr << coda vuota << endl; exit(-1); CodaItem<T> *pt = testa; testa = testa->succ; T val = pt->item; delete pt; return val; /02 21

22 Relazioni di Amicizia per di Classi Esistono tre tipi di dichiarazioni di amicizia che possono comparire nella definizione di un template di classi class F; class CodaItem { friend class F; friend void f(); friend void F::f(); ; Le classi e le funzioni non template sono amiche di ogni istanza del template 42 Istanziazione dei Metodi di un di Classi I metodi di un template di classi vengono istanziati quando sono invocati per la prima volta L istanziazione dei metodi segue le regole dell istanziazione dei template di funzioni Il C++ pre-standard istanzia tutti i metodi del template di classi contemporaneamente alla istanziazione della classe /02 22

23 Relazioni di Amicizia per di Classi class F; void f(codaitem<t>); class Coda { friend class F<T>; friend void f(codaitem<t>); friend void F<T>::f(); ; Ogni istanza della classe F è amica della corrispondente classe Coda 44 Relazioni di Amicizia per di Classi class CodaItem { template <class U> friend class F; template <class U> friend void f(codaitem<u>); template <class U> friend void F<U>::f(); ; Tutte le istanze della classe F sono amiche di ogni istanza della classe CodaItem /02 23

24 Relazioni di Amicizia tra Coda e CodaItem class CodaItem { friend class Coda<T>; friend ostream& operator<<(ostream&, CodaItem<T>&); private: CodaItem(const T&); CodaItem<T>* succ; T item; ; 46 Output di Coda e CodaItem ostream& operator<<( ostream &os, const CodaItem<T> &qi ) { os << qi.item; return os; ostream& operator<<( ostream &os, const Coda<T> &q ) { os << "< "; CodaItem<T> *p; for ( p = q.testa; p; p = p->succ ) os << *p << " "; os << " >"; return os; /02 24

25 Elementi static di un Un template di classi può dichiarare dei membri static ogni istanza del template avrà le proprie copie dei dati static i dati static sono comuni solo tra variabili dello stesso tipo di istanziazione I dati static vengono istanziati solo quando vengono usati per la prima volta La sintassi per inizializzare un dato static di un template è int Coda<T>::cont = 1; 48 Membri static di CodaItem class CodaItem { friend class Coda<T>; friend ostream& operator<<(ostream&, CodaItem<T>&); private: static const unsigned int _blocco; static CodaItem<T>* free_list; CodaItem(const T&); void* operator new(size_t); void operator delete(void*, size_t); CodaItem<T>* succ; T item; ; CodaItem<T>* CodaItem<T>::free_list = 0; const unsigned int CodaItem<T>::_blocco = 24; /02 25

26 Uso Membri static di CodaItem void* CodaItem<T>::operator new( size_t size ) { CodaItem<T> *p; if (! free_list ) { size_t blo = _blocco * size; free_list = p = reinterpret_cast<codaitem<t>* > ( new char[blo] ); for ( ; p!= &free_list[ CodaItem_blocco - 1 ]; ++p ) p->succ = p + 1; p->succ = 0; p = free_list; free_list = free_list->succ; return p; 50 Uso Membri static di CodaItem void CodaItem<T>::operator delete( void *p, size_t ) { static_cast< CodaItem<T>* >( p )->succ = free_list; free_list = static_cast< CodaItem<T>* > ( p ); /02 26

27 Membri Il C++ standard consente la definizione di metodi template all interno di classi (sia template che non template) Tecnica ampiamente utilizzata nella libreria standard per supportare la programmazione generica Non supportata da compilatori pre-standard Ogni istanza della classe template contiene tutte le istanze del metodo template Il metodo template è istanziato quando viene invocato 52 Specializzazione di un di Classi E possibile definire delle versioni specializzate del template della classe template <> class Coda<LongDouble> { ; La specializzazione deve seguire la definizione del template La specializzazione deve essere inseritain tutti i file del programma In questo caso bisogna fornire le specializzazioni per tutti i metodi del template della classe E possibile definire anche solo la specializzazione di alcuni metodi della classe class LongDouble; template <> LongDouble Coda::remove() { /02 27

28 Specializzazioni Parziali Se il template ha più parametri è possibile fornire una specializzazione per solo uno dei parametri Può fornire implementazioni più efficienti per specifici valori del parametro 54 Risoluzione dei Nomi nei Ogni istanza del template ha un proprio scope locale il compilatore cerca di risolvere, se possibile, i nomi quando legge la definizione del template i nomi non dipendenti dal template sono risolti subito i nomi dipendenti dal template sono risolti dopo l'istanziazione Un nome potrebbe essere risolto con una variabile non visibile al momento della definizione del template T min(t* array, int size) { // size non dipende dal template T minval = array[0]; // minval dipende dal template for(int i = 1; i < size; i++) if(array[i] < minval) minval = array[i]; return minval; /02 28

29 Risoluzione dei Nomi nei Quando il template contiene una chiamata a funzione se tra gli argomenti non ci sono variabili dipendenti dal template la funzione deve essere dichiarata prima della definizione del template se tra gli argomenti ci sono variabili dipendenti dal template la funzione deve essere dichiarata prima della istanziazione del template T min(t* array, int size) { T minval = array[0]; // minval dipende dal template for(int i = 1; i < size; i++) if(array[i] < minval) minval = array[i]; print(minval); // print non dichiarata return minval; 56 Modelli di Compilazione di Al momento dell'istanziazione del template il compilatore deve produrre il codice del'istanza deve conoscere la definizione del template il compilatore deve interrompere la compilazione, risolvere i valori da assegnare ai parametri e generare la classe La definizione di una classe non determina allocazione di memoria La definizione di una classe può essere inserita più volte all interno dello stesso programma La definizione di un template di classe va inserita in un file di intestazione Il file viene incluso in tutti i file in cui deve essere istanziato il template /02 29

30 Modelli di Compilazione di I metodi del template di classi e i membri static si comportano come template di funzioni Le definizioni devono essere visibili nel punto in cui vengono istanziati I metodi sono istanziati solo quando vengono invocati per la prima volta Il C++ standard supporta due modelli di compilazione dei template di funzioni modello ad inclusione modello a separazione 58 Modello ad Inclusione La definizione di un metodo del template deve essere inclusi in ognuno dei file in cui il template è istanziato il template viene inserito in un header file la definizione del template è trattata come le funzioni inline Se l'header file viene incluso in più di un file il compilatore deve generare una sola copia di ogni istanza del template L implementazione dipende dal compilatore molti compilatori generano istanze del template in ogni file. Il linker seleziona una sola istanza e la utilizza per tutte le chiamate /02 30

31 Modello ad Inclusione in g++ Il g++ supporta il modello ad inclusione istanzia i template in tutti i file in cui sono richiesti solo una di queste istanziazioni è utilizzata Questo modello di compilazione è inefficiente sia per tempo che per spazio Possibile migliorare i tempi di compilazione dicendo al compilatore di non generare tutte queste copie 60 Istanziazione Esplicita Per obbligare il compilatore a generare una certa istanza in un file è possibile inserire una dichiarazione di istanziazione esplicita Istanzia sia la classe che tutti i suoi metodi Le definizioni dei metodi devono essere visibili l istanziazione esplicita si deve trovare nello stesso file della definizione dei template di funzione In genere si inserisce la definizione del template in un file di implementazione insieme alle istanziazioni esplicite template class Coda<int>; Bisogna garantire che il compilatore non istanzi gli stessi metodi anche in altri file si usa un opzione di compilazione per dire al compilatore di istanziare template solo se il programma ne fa richiesta esplicita in g++ Opzione no_implicit_istantiation /02 31

32 Modello a Separazione La dichiarazione del template viene inclusa in ogni file dove il template è utilizzato. La definizione viene inclusa in un file di implementazione linkato al programma le istanze del template sono gestite come le funzioni non inline la definizione del template deve essere resa visibile a tutti i file export T min(t x, T y) { export Coda { ; su molti compilatori questa organizzazione non funziona (Es. g++) 62 Esempio file min.h file min.c file main.c T min(t, T); export T min(t a, T b) { return (a < b? a : b); #include min.h main() { int i = min(3, 6); /02 32