Template (Programmierung)
aus Wikipedia, der freien Enzyklopädie
 |
Dieser Artikel oder Abschnitt ist nicht hinreichend mit Belegen (Literatur, Webseiten oder Einzelnachweisen) ausgestattet. Die fraglichen Angaben werden daher möglicherweise demnächst gelöscht. Hilf Wikipedia, indem du die Angaben recherchierst und gute Belege einfügst. Bitte entferne zuletzt diese Warnmarkierung. |
Templates (engl.: Schablonen) sind „Programmgerüste“, die bei Bedarf vom Compiler instantiiert, also als normale Klassen oder Funktionen zur Verfügung gestellt, werden. Templates ermöglichen generische Programmierung und Typsichere Container, bei denen vom Klassennutzer die enthaltenen Typen angegeben werden können.
In C++ sind Templates von großem Nutzen, insbesondere wenn sie mit Vererbung und Überladen von Operatoren kombiniert werden. Auch die C++-Standardbibliothek stellt viele nützliche Komponenten in Form eines Template-Frameworks zur Verfügung.
D unterstützt Templates in einer sehr ähnlichen Form mit einer leicht verschiedenen Syntax. Es besteht jedoch keine Möglichkeit C++-Templates in D oder umgekehrt D-Templates in C++ zu nutzen. D unterstützt zwar keine mehrfache Klassenvererbung, doch Mixins erlauben meist dieselben Dinge, die in C++ im Zusammenhang mit Templates durch Vererbung gelöst werden.
In anderen Programmiersprachen (z. B. Java [1] oder C# [2]) gibt es ein zu Templates ähnliches Konzept unter dem Namen „generischer Typ“. Generische Typen stellen jedoch keine Code-Generatoren dar, sondern ermöglichen lediglich typsichere Container.
Inhaltsverzeichnis |
[Bearbeiten] Arten von Templates
Es gibt zwei Arten von Templates in C++: Funktionstemplates und Klassentemplates.
[Bearbeiten] Funktionstemplates
Ein Funktionstemplate (auch Templatefunktion genannt) verhält sich wie eine Funktion, die in der Lage ist, Argumente verschiedener Typen entgegenzunehmen, und/oder verschiedene Rückgabetypen zu liefern. Die C++-Standardbibliothek enthält beispielsweise das Funktionstemplate std::max(x, y). Es gibt entweder x oder y zurück, und zwar abhängig davon, welches der beiden Argumente größer ist. Es könnte etwa folgendermaßen definiert sein:
template < typename T > T max(T x, T y) { if (x < y) return y; else return x; }
Dieses Template kann genauso aufgerufen werden wie eine Funktion:
cout << max(3, 7); // gibt 7 aus
Anhand der Argumente macht der Compiler fest, dass es sich um einen Aufruf an max(int, int) handelt und erzeugt eine Variante der Funktion, bei der der Typ T zu int festgelegt wird.
Der Templateparameter könnte auch explizit angegeben werden:
cout << max<int>(3, 7); // gibt ebenfalls 7 aus
Das Funktionstemplate max() lässt sich für jeden Typ instanziieren, für den der Vergleich x < y eine wohldefinierte Operation darstellt. Bei selbstdefinierten Typen macht man von Operator-Überladung Gebrauch, um die Bedeutung von < für den Typ festzulegen und dadurch die Verwendung von max() für den betreffenden Typ zu ermöglichen.
Der C++-Sprachstandard formuliert die Anforderungen an Datentypen und ihre Operatoren für die Verwendung mit als Funktionstemplate definierten Standardalgorithmen. Im Zusammenspiel mit der C++-Standardbibliothek erschließt sich eine enorme Funktionalität für einen selbstdefinierten Typ durch die Definition einiger Operatoren. Allein schon durch die Definition eines eine strenge schwache Ordnung realisierenden Vergleichsoperators < werden die Standardalgorithmen std::sort(), std::stable_sort(), und std::binary_search() für den Typ anwendbar. Ein solcher Operator erlaubt auch die Verwendung des Typs als Element von als Klassentemplate definierten Datenstrukturen wie Mengen und assoziativen Feldern.
[Bearbeiten] Klassentemplates
Ein Klassentemplate (auch fälschlich Templateklasse genannt) wendet das gleiche Prinzip auf Klassen an. Klassentemplates werden oft zur Erstellung von generischen Containern verwendet. Beispielsweise verfügt die C++-Standardbibliothek über einen Container, der eine verkettete Liste implementiert. Um eine verkettete Liste von int zu erstellen, schreibt man einfach list<int>. Eine verkettete Liste von Objekten des Datentypes string wird zu list<string>. Mit list ist ein Satz von Standardfunktionen definiert, die immer verfügbar sind, egal was man als Argumenttyp in den spitzen Klammern angibt. Die Werte in spitzen Klammern werden Parameter genannt. Wenn ein Klassentemplate mit seinen Parametern dem Compiler übergeben wird, so kann dieser das Template ausprägen. Er erzeugt hierbei zu jedem Parametertyp eine eigene Templateklasse. Diese ist eine gewöhnliche Klasse, wie jede andere auch. Die Begriffe Klassentemplate und Templateklasse sind hier von einander zu unterscheiden. Wie Objekt und Klasse ist die Templateklasse eine Ausprägung eines Klassentemplates.
Templates sind sowohl für mit class als auch für mit struct definierte Klassen anwendbar. Auch Template-Unions sind möglich. Typedefs und Namespaces lassen sich dagegen nicht als Template anlegen.
[Bearbeiten] Spezialisierung
Templates lassen sich spezialisieren, d. h. man kann Klassen- und Funktionstemplates (für bestimmte Datentypen als Template-Argumente) gesondert implementieren. Dies erlaubt eine effizientere Implementierung für bestimmte ausgewählte Datentypen, ohne die Schnittstelle des Templates zu verändern. Davon machen auch viele Implementierungen der C++-Standardbibliothek (beispielsweise die der GCC) Gebrauch.
[Bearbeiten] Spezialisierung bei Klassentemplates
Die Containerklasse std::vector der C++-Standardbibliothek kann für den Elementtyp bool als Bitmap implementiert werden, was hilft Speicherplatz einzusparen. Auch entnimmt das Klassentemplate std::basic_string die Informationen zum Umgang mit den einzelnen Zeichen der Struktur char_traits, die für den Datentyp char und beispielsweise auch wchar_t spezialisiert ist.
Die Deklaration von Spezialisierungen ähnelt der von normalen Templates, allerdings sind die dem Schlüsselwort template folgenden spitzen Klammern leer, und dem Funktions- bzw. Klassennamen folgen die Templateparameter.
Beispiel:
template <> class vector< bool > { // Implementierung von vector als Bitmap };
[Bearbeiten] Partielle Spezialisierung
Des Weiteren gibt es auch die so genannte partielle Spezialisierung, die die Behandlung von Spezialfällen innerhalb eines Templates ermöglicht.
Beispiel:
template < int zeilen, int spalten > class Matrix { // Implementierung einer Matrix-Klasse }; template < int zeilen > class Matrix< zeilen, 1 > { // Implementierung einer 1-spaltigen Matrix-Klasse };
Wichtig zu erwähnen ist, dass beide Klassen komplett voneinander unabhängig sind, d. h. sie erben weder Konstruktoren oder Destruktoren noch Elementfunktionen bzw. Datenelemente voneinander.
[Bearbeiten] Spezialisierung bei Funktionstemplates
Im Unterschied zu Klassentemplates sind Funktionstemplates nicht teilweise (nur vollständig) spezialisierbar. Allerdings wird von der Spezialisierung von Funktionstemplates allgemein abgeraten, da die Regeln für die Bestimmung der „am besten passenden“ Funktion sonst zu unintuitiven Ergebnissen führen können (siehe [1]).
Durch Überladen von Funktionstemplates mit anderen Funktionstemplates kann man in den meisten Fällen das Gleiche erreichen wie durch die (nicht zulässige) teilweise Spezialisierung. Falls diese Technik aus jedwedem Grund im konkreten Fall nicht anwendbar ist – z. B. wenn ein Template von Klassenmethoden spezialisiert werden soll ohne die Klassendefinition zu erweitern – so kann man auch das Problem der Spezialisierung auf ein Template einer Hilfsklasse verlagern:
class Example { private: template< typename T > struct Frobnicator { static T do_frobnicate(T param); }; public: template< typename T > T frobnicate(T param); }; template< typename T > T Example::frobnicate(T param) { // Frobnicator soll die eigentliche Arbeit verrichten return Frobnicator<T>::do_frobnicate(param); } template< typename T > T Example::Frobnicator<T>::do_frobnicate(T param) { // Standardimplementierung ... } template<> int Example::Frobnicator<int>::do_frobnicate(int param) { // ints werden auf andere Weise "frobnifiziert" return (param << 3) + (param % 7) - param + foobar; }
[Bearbeiten] Template-Templates
Mit Template-Templates werden Templates bezeichnet, die wiederum als Parameter von Templates verwendet werden. Sie stellen einen weiteren Abstraktionsmechanismus zur Verfügung. Im folgenden Beispiel wird sowohl der Typ als auch der verwendete Container angegeben; letzterer mit Hilfe eines Template-Templates:
template < template < typename, typename > class Container, typename Type > class Example { Container< Type, std::allocator < Type > > baz; };
Beispiel zur Verwendung:
Example < std::deque, int > example;
