Einführung in C++
Einführung in C++
Templates I Templates I
Template
Typ char Typ int
Typ float
Ausprägung
Templates II Templates II
●
Häufig kommt es vor, dass „gleiche“ Funktionen für verschiedene Typen programmiert werden müssen
●
Mit Hilfe von Templates bietet C++ die Möglichkeit, eine parametrisierte Familie verwandter Funktionen oder Klassen zu definieren:
–
Funktionstemplate legt die Anweisung einer Funktion fest, wobei statt eines konkreten Typs ein Parameter eingesetzt wird.
–
Klassentemplates legt Definition einer Klasse fest, wobei ebenfalls statt eines konkreten Typs ein
Parameter eingesetzt wird.
Templates III Templates III
●
Definition eines Funktiontemplates:
Eingeleitet wird ein Template stets mit dem Präfix:
Der Parameter T ist dabei ein Typname, welcher in der darauf folgenden Implementierung benützt wird.
Beispiel:
Der Parameter T bezeichnet den noch festzulegenden Typ der Variablen template<class T>
template<class T>
void swap(T& x, T& y) { T tmp(x);
x = y;
y = tmp;
}
Templates IV Templates IV
●
Instatiierung von Funktion-Templates:
Eine Template-Funktion wird beim ersten Aufruf
Instantiiert. Den Parameter T ermittelt der Compiler dabei aus dem Typ der übergebenen Parameter.
Beispiel:
short x = 1; y = 5;
swap(x, y); // Template wird für den Typ „short“ erzeugt int a=10; b = 20;
swap(a, b); // Zweite Template vom Typ „int“
Templates V Templates V
●
Definition eines Klassen-Templates:
Hiermit wird ein Klassentemplate MyClass<T> definiert.
Sowohl T als auch MyClass<T> werden dabei wie
„normale“ Typen behandelt.
template<class T>
class MyClass { T element;
// ...
};
Templates VI Templates VI
●
Instantiierung von Klassen-Templates:
Auch ein Klassen-Template wird beim ersten Aufruf Instantiiert. Die Instantiierung erfolgt implizit.
●
Beispiel:
MyClass<int> instanz1(255);
Zunächst wird hierbei ein Template der Klasse „MyClass“ angelegt, wobei für alle Methoden Maschinencode vom Typ „Int“ erzeugt wird.
Erst dann kann ein Objekt „instanz1“ erzeugt werden.
Wird eine weitere Template-Classe z.B. „MyClass<short>“ angelegt, wird für alle Methoden Maschinencode vom Typ „short“ erzeugt.
Templates I Templates I
●
Beispiel:
template<class T> class Stack { public:
Stack() : maxStack(255) { s = new T[maxStack]; index = 0;}
~Stack() {delete[] s;}
bool pop(T *);
private:
int maxStack; T *s; int index;
};
template<class T> bool Stack<T>::push(T set){
if (index >= maxStack) return false;
s[index++] = set // Element einfügen return true;
}
template<class T> bool Stack<T>::pop(T *get) { if (index == 0) return false;
*get = s[index—]; // Element zurückliefern return true;
}
Templates VII Templates VII
●
Mehrere Template-Parameter:
Templates können auch mit mehreren Parametern definiert werden template <class X, class Y>
class MyClass { // ....
}
Hierbei wird ein Klassentemplate vom Typ Stack<T, n> erzeugt.
Parametrisiert durch einen Typ T und einer Integer-Zahl n
Jedoch muss ein Template-Parameter nicht immer Typname sein.
Auch „nomale“ Funktionsparameter (incl. Zeiger und Referenzen) sind erlaubt.
template <class T, int n>
class Stack { // ....
}
