Lezione 7. Introduzione ai Template

Transcript

1 Lezione 7 Template Introduzione ai Template E possibile definire delle funzioni o classi dette generiche ovvero che abbiano come parametro il tipo di dato una funzione (classe) generica definisce una serie di operazioni applicabili ad un qualsiasi tipo di dato ovvero l algoritmo implementato si applica a qualsiasi tipo una funzione (classe) generica si chiama funzione (classe) template 1

2 Sintassi e uso dei Template Sintassi: template<class T> rettype NomeFunzione(T); Uso con dischiarazione esplicita di tipo: int a=2; cout<<nomefunzione<int>(a); Uso con dischiarazione implicita di tipo: int a=2; cout<<nomefunzione(a); Sintassi e uso dei Template Esempio: template<class T> void swap(t& a, T& b){ T temp; temp=a; a=b; b=temp; Uso: int a=1;int b=2; swap(a,b); char c_a= x ;char c_b= y ; swap(c_a,c_b); 2

3 Il Compilatore e i Template Il compilatore genera tutte le istanze utili della funzione template Il procedimento è equivalente ad un overloading automatico Nota: Vengono generate tutte le istanze che servono, che vengono poi effettivamente utilizzate nel codici esecutivo Le funzioni template sono limitate rispetto al caso generale di overloading perché non si possono specificare comportamenti diversi della funzione al variare del tipo #include <iostream> Esempio void f(int i){cout<< il valore è: <<i; void f(char i){cout<< il carattere è: <<i; template<class T> void g(t i){cout<< val: <<i; int a=56; char b= x ; f(a);//stampa: il valore è: 56 f(b);//stampa: il carattere è: x g(a);//stampa: val: 56 g(b);//stampa: val: x 3

4 Funzioni con più di un tipo generico Nel caso in cui si debbano specificare più di due tipi so si fa con la seguente sintassi: Sintassi template<class T1, class T2> rettype F(T1,T2); Es: template<class T1, class T2> void func(t1 x, T2 y){ cout<< prima: <<x<< poi: <<y; Deduzione automatica del tipo Quando viene utilizzata una funzione template è generalmente possibile per il compilatore dedurre automaticamente il tipo template<class T> rettype NomeFunzione(argType (T)); altre volte è impossibile: template<class T1,class T2> rettype NomeFunzione(T1,T2=0); in questo ultimo caso infatti si potrebbe avere ambiguità: template<class T1,class T2> void f(t1,t2=0); void main(){ int a,b; float c,d; f(a,b); f(c,d); f(a,d); f(a); f<int,float>(a); 4

5 Overloading esplicito Se si esegue un overloading esplicito di una funzione template questa maschera quella generata implicitamente template<class T> void g(t i){cout<< val: <<i; void g(char i){cout<< il carattere è: <<i; int a=56; char b= x ; g(a);//stampa: il valore è: 56 g(b);//stampa: il carattere è: x Uso delle funzioni generiche template<class T> T max(t *v, int size){ T max=v[0]; for(int i=1;i<size;i++) if(max<v[i]) max=v[i]; return max; main(){ int arrayi[7]={4,7,2,4,9,3,2; double arrayd[6]={7.1,9.4,2.6,5.7,4.8,6.9 int resi; double resd; resi=max(arrayi,7); resd=max(arrayd,6); 5

6 Classi Template Una classe generica o template può definire i propri membri in modo generico Sintassi in dichiarazione: template<class T> class NomeClasse{; Sintassi in definizione: template<class T> rettype NomeClasse<T>::funcName(argType parameter){ Sintassi in uso: main(){ NomeClasse<type> obj(init); Nota: per le classi si deve sempre esplicitare il tipo nella dichiarazione (non ci sono meccanismi di deduzione automatica) Esempio //Vettore generico template<class T> class Vector{ public: Vector(int usr_size=10){size=usr_size; v=new T[size]; ~Vector(){delete [] v; T& operator[](int); private: int size; T* v; ; template<class T> T& Vector<T>::operator[](int i){ return v[i]; 6

7 Esempio void main{ Vector<int> vi(100); Vector<char> vc(5); int i; for(i=0;i<100;i++) vi[i]=i*i; for(i=0;i<5;i++) vc[i]= e ; for(i=0;i<100;i++) cout<<vi[i]<< ; cout<<endl; Esempio Stack #ifndef TSTACK1_H #define TSTACK1_H template< class T > class Stack { public: Stack( int = 10 ); // default constructor (stack size 10) ~Stack(){delete [] stackptr; // destructor bool push( const T& ); // push an element onto the stack bool pop( T& ); // pop an element off the stack bool isempty() const{return top == -1; // determine //whether Stack is empty bool isfull() const{return top == size - 1; // determine whether Stack is full private: int size; // # of elements in the stack int top; // location of the top element T *stackptr; // pointer to the stack ; 7

8 // constructor template< class T > Stack< T >::Stack( int s ){ size = s > 0? s : 10; top = -1; // Stack initially empty stackptr = new T[ size ]; // allocate memory for elements // push element onto stack; // if successful, return true; otherwise, return false template< class T > bool Stack< T >::push( const T &pushvalue ){ if (!isfull() ) { stackptr[ ++top ] = pushvalue; // place item on Stack return true; // push successful // end if return false; // push unsuccessful // pop element off stack; // if successful, return true; otherwise, return false template< class T > bool Stack< T >::pop( T &popvalue ) { if (!isempty() ) { popvalue = stackptr[ top-- ]; // remove item from Stack return true; // pop successful // end if return false; // pop unsuccessful #endif 8

9 #include <iostream> using std::cout; using std::cin; using std::endl; #include "tstack1.h" // Stack class template definition int main() { Stack< double > doublestack( 5 ); double doublevalue = 1.1; cout << "Pushing elements onto doublestack\n"; while ( doublestack.push( doublevalue ) ) { cout << doublevalue << ' '; doublevalue += 1.1; cout << "\nstack is full. Cannot push " << doublevalue << "\n\npopping elements from doublestack\n"; while ( doublestack.pop( doublevalue ) ) cout << doublevalue << ' '; cout << "\nstack is empty. Cannot pop\n"; Stack< int > intstack; int intvalue = 1; cout << "\npushing elements onto intstack\n"; while ( intstack.push( intvalue ) ) { cout << intvalue << ' '; ++intvalue; 9

10 cout << "\nstack is full. Cannot push " << intvalue << "\n\npopping elements from intstack\n"; while ( intstack.pop( intvalue ) ) cout << intvalue << ' '; cout << "\nstack is empty. Cannot pop\n"; Oggetti funzione Si può simulare il comportamento di una funzione con un oggetto Per fare questo si sovraccarica l operatore parentesi di un oggetto Il risultato è chiamato un oggetto funzione Si usano oggetti funzione per scrivere delle funzioni che accettino altre funzioni come parametri 10

11 Relazione funzione-oggetti Una funzione in realtà è trattata in C++ come una classe di cui è definita solo la funzione membro operator() si può quindi passare come parametro di un template una funzione Oggetti funzione Si dichiara una classe con il metodo ( ) sovraccaricato se si vuole usare la funzione per computare un valore a partider da un parametro: class FuncObj{ public: int operator()(const MyClass & obj){ return f(obj); 11

12 Oggetti funzione Se si vuole usare la funzione per modificare dei dati non si restituisce niente, ma piuttosto si modifica il parametro passato per riferimento class FuncObj{ public: void operator()(myclass & obj){ //modifica di obj Oggetti funzione Oppure si usa l oggetto funzione per verificare una condizione complessa in questo caso si restituisce un bool class FuncObj{ public: bool operator()(myclass & obj){ if//verifica di proprietà di obj return true; else return false; 12

13 Oggetti funzione Questa tecnica diviene molto utile quando usata insieme ai template si consideri la seguente funzione template template<class Ob, class F> void for_each(ob* my_obj, int num, F func){ for(int i=0;i<num;i++) func(*(my_obj++)); La funzione for_each applica la funzione func a tutti gli oggetti in un vettore di cui è noto il puntatore al primo elemento e il numero di elementi class Complex{ public: Complex(double r=0, double i=0):re(r),im(i){ void operator+=(const Complex z){re+=z.re; im+=z.im; private: double re,im; ; void add23(complex &c){ c+=complex(2,3); ; const int dim=100; Complex *cv=new Complex[dim]; for_each(cv,dim,add23); 13

14 Oggetti funzione Come si può rendere l esempio più generico? Come fare per passare alla funzione una parte reale e immaginaria arbitraria da aggiungere? Si potrebbe definire un oggetto funzione e immagazzinare il valore in un dato membro class Add{ public: Add(Complex c):val(c){ void operator()(complex & c)const{c+=val; private: Complex val; ; const int dim=100; Complex *cv=new Complex[dim]; Complex z(2,3); for_each(cv,dim,add(z)); 14

15 Oppure: const int dim=100; Complex *cv=new Complex[dim]; Complex z(2,3); Add myadd(z); for_each(cv,dim,myadd); Oggetti funzione Nel caso di valutazione di un predicato si consideri invece una funzione che stampa un valore solo se un criterio è soddisfatto, come: template<class Ob,class P> void print_if(ob & my_obj, P pred){ if(pred(my_obj)) cout<<my_obj; 15

16 class Odd{ public: bool operator()(complex & c)const{return (c.re%2); ; const int dim=100; Complex *cv=new Complex[dim]; for(int i=0;i<dim;i++) print_if(*(cv++),odd()); Nota Si noti che nel template è specificato che il secondo parametro è un oggetto e non un tipo pertanto non è corretto scrivere print_if(*cv,odd); poiché Even è un tipo definito dall utente e non un oggetto tuttavia Even() è un oggetto, anche se un oggetto senza nome questo oggetto viene copiato nel secondo argomento di print_if dove acquista il nome di pred il metodo operator() di pred viene poi utilizzato per valutare l espressione 16

17 Nota L oggetto funzione Odd ha il metodo operator() sovraccaricato che restituisce un valore booleano se la parte reale del numero passato come argomento è divisibile per due, ovvero il resto (modulo) della divisione per due è 0 allora il risultato è 0=false, altrimenti è vero in altri termini se è divisibile per due è falso che sia dispari (infatti è pari) si sarebe potuto scrivere una funzione Even come return!((c.re%2)==0); Namespace I namespace permettono di raggruppare classi, funzioni e variabili sotto un unico nome. E un modo per dividere l ambito di visibilità globale (global scope) in sotto-ambiti (sub-scopes) Per dichiarare un namespace: namespace identificatore{ corpo ad es: namespace general{ int a,b; 17

18 Accesso al namespace Per accedere alle classi,funzioni o variabili di un namespace si deve risolvere la visibilità tramite l operatore :: general::a general::b Utilità del namespace Il concetto di namespace è utile quando vi è la possibilità che vi siano due o piu un oggetti globali o funzioni o variabili globali che abbiano lo stesso nome namespace first{ int var=5; namespace second{ double var=3.14; void main(){ cout<<first::var<< <<second::var<<endl; 18

19 La direttiva using Per poter accedere agli elementi di un namespace come se questi fossero definiti nell ambito globale, si usa la direttiva: using namespace identificatore; in questo modo non si deve risolvere ogni volta il namespace Il namespace std Uno degli esempi più utili di namspace è quello della libreria standard C++ Tutte le classi, oggetti e funzioni della libreria standard C++ sono definite nel namespace std #include<iostream> std::cout<< Ciao <<std::endl; oppure: #include<iostream> using namespace std; cout<< Ciao <<endl; 19