Container/ Collection: Klasse die (Pointer auf ) andere Klassen oder Typen int,char,bool etc. aufnimmt.

Transkript

1 Templates Container/ Collection: Klasse die (Pointer auf ) andere Klassen oder Typen int,char,bool etc. aufnimmt. Bsp.: einfach verkettete Liste Data Data Data Data Jeder Datenknoten nimmt ein Datenobjekt auf, und besitzt einen Zeiger auf den nächsten Knoten. Eine Knotenklasse die TH1- Histogramme aufnimmt: class datanode void Insert(TH1 input) data = input;...; TH1 GetElement()return data;... private: TH1 data; datanode* next; ; Mit dieser Klasse lässt sich eine verkettete Liste implementieren, die TH1 aufnimmt. Jetzt soll aber eine weitere Liste mit ansonsten gleicher Funktionalität THelix- Objekte aufnehmen.

2 Lösung 1: Die Liste und die Datenknoten werden mit Copy&Paste für jeden aufzunehmenden Datentypen neu implementiert. Nachteil: Sehr fehleranfällig, schwer zu wartender Code Lösung 2: Man schreibt eine Liste die Pointer auf einen Basisdatentyp TObject aufnimmt, jeder zu speichernde Datentyp ist von TObject abzuleiten. Container TObject TObject TH1 TObject THelix Nachteil: Man erhält komplex e Vererbungshierarchien. Viele abgeleitete Klassen haben nichts miteinander gemein. Die TObject Methode Draw() macht nicht für jede abgeleitete Klasse Sinn, etwa für TEventList

3 Lösung 3: Templates In C+ + realisiert durch die Standard Template Library (STL): vector, list, map... vector<th1> histovec; vector<thelix> helixvec; TH1 histo; THelix helix; histovec.push_back(histo); helixvec.push_back(helix); Der Compiler erzeugt für jede übergebene Argumentenliste <TH1>, <THelix> die entsprechende Vektorklasse. Jede dieser Klassen besitzt die gleichen Methoden pop(),size()...

4 Templates selbst erstellen Im Folgenden wird eine sehr einfache Containerklasse betrachtet, die nur ein Datenelement aufnimmt, zunächst int: class container container(int input):data(input) void Insert(int input)data = input; int GetElement()return data; private: int data; ; int a = 5; container intcont(a); int b = intcont.getelement(); return 0; Einer Parametrisierung dieser Klasse wird das Schlüsselwort template vorangestellt, gefolgt von einer Parameterliste <class T>. Auch mehrere Parameter und/ oder Standardwerte sind möglich:<class T, class U = float> Das Schlüsselwort class kennzeichnet den Platzhalter T als Typen, er steht also in der Templatedefinition für int, float, char, double*,int*, usw. oder selbst erstellte Klassen

5 Parametrisierung der Klasse container class container container(t input):data(input) void Insert(T input)data = input; T GetElement()return data; private: T data; ; container<th1> histocontainer; container<int> intcontainer; TH1 histo; int a = 5; histocontainer.insert(histo); intcontainer.insert(a);... Im Hauptprogramm wird das Template durch Übergabe einer Argumentliste instantiiert:container<th1> Der Compiler ersetzt in der Templatedefinition den Parameter T durch das Argument TH1,und erzeugt so eine spezielle Containerklasse für TH1- Histogramme.

6 Definition von member functions inline: wie gehabt class container T GetElement()return data;... ; nicht inline: class container T GetElement();... ; T container<t>::getelement() return data; Das Schlüsselwort template gilt nur für den nachfolgenden Block

7 Spezialisierung von Klassentemplates explizit (full specialisation): Der Container soll für den Typ int eine spezielle Funktionalität aufweisen, z.b. das Element inkrementieren class container...; template<> class container<int> container(int input):data(input) void Insert(int input)data = input; int GetElement()return data; void increment()++data; private: int data; ; int a = 5; container<int> intcontainer(a); Container.increment();... Die spezialisierte Klasse container<int> besitzt keine Parameterliste mehr, sondern eine Argumentenliste Durch Übergabe des Argumentes <int> wird die spezialisierte Klasse instantiiert, und die geforderte Funktionalität bereit gestellt

8 partielle Spezialisierung: Oft ist es nötig für eine Untermenge der Parametermenge eine spezielle Implementierung zu schreiben. Das Template kenn jeden Typ übernehmen, z.b.: int, float, double Aber auch int*, float*, double* sind erlaubte Typen. Das Inkrementieren von Pointern ist natürlich etwas anderes als das Inkrementieren des vom Pointer referenzierten Objektes. Somit führt das folgende Beispiel zu unerwarteten Ergebnissen class container container(t input):data(input) void increment()++data; private: T data; ; int x = 5; int* xptr = &x; container intcont(xptr); intcont.increment(); Eine partielle Spezialisierung besitzt eine Parameterliste, und eine Argumentenliste. Die Argumente sind dabei eine Untermenge der erlaubten Parameter Eine Untermenge sind z.b. Pointer

9 partielle Spezialisierung der Containerklasse für Pointer class container...; class container<t*> container(t* input):data(input) void increment()++(*data); private: T* data; ; int x = 5; int* xptr = &x; container intcont(x); intcont.increment(); container intptrcont(xptr); inptrcont.increment(); Wird das Template nun mit einem Pointertyp instantiiert, so wählt der Compiler automatisch die Spezialisierung (solange durch verschiedene Spezialisierungen keine Mehrdeutigkeiten entstehen)

10 Funktionstemplates Auch Funktionen lassen sich parametrisieren, so dass sie für verschiedene Typen gleiche Aufgaben erfüllen int getmin(int a, int b) if (a < b) return a; return b; int x = 5; int y = 7; int min; min = getmin(x,y); Für double oder float Argumente wird diese Funktion i.a. falsche Ergebnisse zurückgeben, user Klassen gar nicht erst annehmen T getmin(t a, T b) if (a < b) return a; return b; float v = 3.6; float w = 3.2; float min; min = getmin<float>(v,w); Das Argument in der Instantiierung kann auch weggelassen werden wenn es eindeutig aus dem Kontex t hervorgeht. Auch hier ergeben sich Probleme wenn Pointer übergeben werden, daher...

11 Überladen und Spezialisieren von Funktionstemplates T getmin(t a, T b)... T* getmin(t* a, T* b) if (*a < *b) return a; return b; int x = 5; int y = 7; int* xptr = &x; int* yptr = &y; int* min; min = getmin(xptr,yptr); Wird die Funktion mit Pointern aufgerufen, so wählt der Compiler automatisch das Template, das Pointer als Funktionsargumente erwartet. Ein Template lässt sich auch mit nicht- Templatefunktionen überladen, z.b durch double getmin(double a, double b)... explizite Spezialisierung für char: template<> char getmin<char>(char a, char b) cout << 'keine Zahlen '; return a; Im Gegensatz zu Klassentemplates lassen sich Funktionstemplates nicht partiell spezialisieren

12 Anmerkungen Der Template- Mechanismus laesst auch Vererbung zu: a...; template<classt> b : public a<t>...;