C++-Programmierung/ Templates

Aus Wikibooks
Zur Navigation springen Zur Suche springen
Templates
RedDeerStag.jpg

Zielgruppe:

Anfänger

Lernziel:
Lernen was Templates sind und wie man sie einsetzt.


Funktionstemplates [Bearbeiten]

Ein Funktionstemplate ist eine „Mustervorlage“ oder „Schablone“, die dem Compiler mitteilt, wie eine Funktion erzeugt werden soll. Aus einem Template können semantisch gleichartige Funktionen mit verschiedenen Parametertypen erzeugt werden. Für alle, die eben in Panik zu Wiktionary oder einem noch schwereren Wörterbuch gegriffen haben: semantisch heißt hier so viel, wie allgemein gehalten in Bezug auf den Datentyp. Die Funktion hat also immer die gleiche Parameteranzahl, die Parameter haben aber unterschiedliche Datentypen. Das ist zwar nicht ganz korrekt ausgedrückt, aber eine genaue Definition würde das Wort wieder so unverständlich machen, dass es ohne Erklärung weniger Schrecken verbreitet hätte. Lesen Sie einfach das Kapitel, dann werden Sie auf einige der „fehlenden Klauseln“ selbst aufmerksam werden.

Das nachfolgende Template kann Funktionen generieren, welche die größere von zwei Zahlen zurückliefern. Der Datentyp spielt dabei erst einmal keine Rolle. Wichtig ist nur, dass es zwei Variablen gleichen Typs sind. Die Funktion liefert dann einen Wert zurück, der ebenfalls dem Datentyp der Parameter entspricht.

Nuvola-inspired-terminal.svg
1 template <typename T>
2 T maxi(T obj1, T obj2){
3     if(obj1 > obj2)
4         return obj1;
5     else
6         return obj2;
7 }

Das Template wird mit dem gleichnamigen, aber kleingeschriebenen Schlüsselwort template eingeleitet. Danach folgt eine spitze Klammer und ein weiteres Schlüsselwort namens typename. Früher hat man an dieser Stelle auch das gleichbedeutende Schlüsselwort class benutzt. Das funktioniert heute immer noch, ist aber nicht mehr üblich. Erstens symbolisiert typename besser was folgt, nämlich einen Platzhalter, der für einen Datentyp steht, und zweitens ist es einfach übersichtlicher. Dies gilt insbesondere bei Klassentemplates, die aber Thema des nächsten Kapitels sind.

Als Nächstes folgt wie schon gesagt der Platzhalter. Er kann die gleichen Namen haben wie eine Variable sie haben könnte. Es ist aber allgemein üblich, den Platzhalter als T (für Typ) zu bezeichnen. Das soll natürlich nur ein Vorschlag sein – viele Programmierer haben da auch ihren eigenen Stil. Wichtig ist nur, dass Sie sich nicht zu viele Bezeichner suchen, es sei denn Sie haben ein ausgesprochenes Talent dafür, aussagekräftige Namen zu finden. Am Ende dieser Einführung wird die spitze Klammer geschlossen. Dann wird ganz normal die Funktion geschrieben mit der einen Ausnahme, dass anstatt eines genauen Datentypes einfach der Platzhalter angegeben wird.

Sie können diese Funktion dann z.B. mit int- oder double-Werten aufrufen:

Nuvola-inspired-terminal.svg
1 int a = 3, b = 5;
2 int m = maxi(a, b);                    // m == 5
3 m = maxi(3, 7);                        // m == 7
Nuvola-inspired-terminal.svg
1 double a = 3.3, b = 3.4;
2 double m = maxi(a, b);                  // m == 3.4
3 m = maxi(a, 6.33);                     // m == 6.33

Bei jedem ersten Aufruf einer solchen Funktion erstellt der Compiler aus dem Template eine echte Funktion, wobei er den Platzhalter durch den tatsächlichen Datentyp ersetzt. Welcher Datentyp das ist, entscheidet der Compiler anhand der übergebenen Argumente. Bei diesem Aufruf findet keine Typumwandlung statt. Es ist also nicht möglich, einen int- und einen double-Wert an die Templatefunktion zu übergeben. Das nächste Beispiel wird das verdeutlichen:

Crystal Clear action button cancel.svg
 1 int a = 3;
 2 double b = 5.4;
 3 double m;                         // Ergebnis
 4 
 5 m = maxi(a, b);                  // funktioniert nicht
 6 m = maxi(4.5, 3);                // funktioniert nicht
 7 m = maxi(4.5, 3.0);              // funktioniert
 8 m = maxi(a, 4.8);                // funktioniert nicht
 9 m = maxi(7, b);                  // funktioniert nicht
10 m = maxi(a, 5);                  // funktioniert
11 m = maxi(7.0, b);                // funktioniert

Möchten Sie eine andere Variante als jene, die anhand der Argumente aufgerufen wird benutzen, müssen Sie die gewünschte Variante explizit angeben:

Nuvola-inspired-terminal.svg
1 double a = 3.0, b = 5.4;
2 double m = maxi<int>(a, b);             // m == 5.0
3 int n = maxi<int>(a, b);             // n == 5

Diese Templatefunktion kann nun mit allen Datentypen aufgerufen werden, die sich nach der Ersetzung des Platzhalters durch den konkreten Datentyp auch übersetzen lassen. In unserem Fall wäre die einzige Voraussetzung, dass auf den Datentyp der Operator > angewandt werden kann und ein Kopierkonstruktor vorhanden ist, da die Werte mit „call by value“, also als Kopie übergeben werden.

Das ist beispielsweise auch bei C++-Zeichenketten, also Objekte der Klasse std::string mit Headerdatei: string, der Fall. Daher ist folgendes problemlos möglich:

Nuvola-inspired-terminal.svg
1 std::string s1("alpha");
2 std::string s2("omega");
3 std::string smax = maxi(s1,s2);        //smax == omega

Spezialisierung[Bearbeiten]

Im Gegensatz zu normalen Funktionen können Templatefunktionen nicht einfach überladen werden, da das Template ja eine Schablone für Funktionen ist und somit bereits für jeden Datentyp eine Überladung bereitstellt. Manchmal ist es aber so, dass das allgemein gehaltene Template für bestimmte Datentypen keine sinnvolle Funktion erzeugt. In unserem Beispiel würde dies für C-Strings zutreffen:

Nuvola-inspired-terminal.svg
1 const char* maxi(const char* str1, const char* str2){
2     if(str1 > str2)
3         return str1;
4     else
5         return str2;
6 }

Beim Aufruf von maxi("Ich bin ein String!", "Ich auch!") würde die oben stehende Funktion aus dem Template erzeugt. Das Ergebnis wäre aber nicht wie gewünscht die dem ASCII-Code nach größere Zeichenkette, sondern einfach die, dessen Adresse im Arbeitsspeicher größer ist. Um C-Strings zu vergleichen gibt es eine Funktion in der Headerdatei cstring (oder in der veralteten Fassung string.h).

Um nun dem Compiler beizubringen, wie er maxi() für C-Strings zu implementieren hat, muss diese Variante spezialisiert werden. Das heißt, es wird für einen bestimmten Datentyp (in diesem Fall const char*) eine von der Mustervorlage (also dem Template) abweichende Version definiert. Für das nächste Beispiel muss die Headerdatei cstring inkludiert werden.

Nuvola-inspired-terminal.svg
1 template <>
2 const char* maxi(const char* str1, const char* str2){
3     if(strcmp(str1, str2) > 0) // strcmp vergleicht zwei C-Strings
4         return str1;
5     else
6         return str2;
7 }

Eine Spezialisierung leitet man immer mit dem Schlüsselwort template gefolgt von einer öffnenden und einer schließenden spitzen Klammer ein. Der Name der Funktion ist identisch mit dem des Templates (maxi), und alle T werden durch den konkreten Typ const char* ersetzt. Der Rumpf der Funktion kann dann völlig beliebig gestaltet werden. Natürlich ist es Sinn und Zweck der Sache, ihn so zu schreiben, dass die Spezialisierung das gewünschte sinnvolle Ergebnis liefert.

Übrigens wäre es auch möglich, den als Beispiel dienenden Aufruf von oben als maxi<std::string>("Ich bin ein String!", "Ich auch!") zu schreiben. Dann würden die beiden C-Strings vor dem Aufruf in C++-Strings umgewandelt, und die können ja problemlos mit > verglichen werden. Diese Methode hat aber drei entscheidende Nachteile gegenüber einer Spezialisierung für C-Strings:

  • Die Headerdatei string muss jedes Mal inkludiert werden
  • Der Aufruf von maxi("Ich bin ein String!", "Ich auch!") ist weiterhin problemlos möglich und liefert auch weiterhin ein dem Zufall überlassenes Ergebnis
  • Diese Art der Lösung ist viel langsamer als die Variante mit der Spezialisierung

Zwischen Spezialisierung und Überladung[Bearbeiten]

Die folgende Überladung der Templatefunktion maxi() ist ebenfalls problemlos möglich und scheint auf den ersten Blick prima zu funktionieren:

Nuvola-inspired-terminal.svg
1 // template <> - ohne das ist es keine Spezialisierung, sondern eine Überladung
2 const char* maxi(const char* str1, const char* str2){
3     if(strcmp(str1, str2) > 0)
4         return str1;
5     else
6         return str2;
7 }
Symbol opinion vote.svg
Hinweis

Um es gleich vorwegzunehmen: das hier beschriebene Problem lässt sich leicht herbeiführen, ist aber nur sehr schwer zu finden. Daher achten Sie darauf, es zu vermeiden. Vergessen Sie auf keinen Fall template <> voranzustellen, wenn Sie ein Template spezialisieren.

Das Ausführen der nächsten beiden Codezeilen führt zum Aufruf verschiedener Funktionen. Die Funktionen haben identische Parametertypen und Namen sowie die gleiche Parameteranzahl, aber eben nicht den gleichen Code.

Nuvola-inspired-terminal.svg
1 // Überladene Version - Ergebnis korrekt
2 cout << maxi("Ich bin ein String!", "Ich auch!");
3 
4 // Vom Template erzeugte Version - Ergebnis zufällig (Speicheradressen)
5 cout << maxi<const char*>("Ich bin ein String!", "Ich auch!");

So etwas sollten Sie um jeden Preis vermeiden! Selbst ein erfahrener Programmierer dürfte über einen Fehler dieser Art erst einmal sehr erstaunt sein. Sie können die beiden Codezeilen ja jemandem zeigen, der sich gut auskennt und ihn fragen, was der Grund dafür sein könnte, dass die Varianten zwei verschiedene Ergebnisse liefern. Ohne die Implementierung von maxi() zu sehen wird er höchst wahrscheinlich nicht darauf kommen. Ein solcher Fehler ist nur schwer zu finden. Es ist bereits eine Katastrophe, ihn überhaupt erst einmal zu machen. Merken Sie sich also unbedingt, dass man template <> nur vor eine Funktion schreibt, wenn man für einen bestimmten Datentyp die Funktionsweise ändern will, weil die Standardvorlage kein sinnvolles Ergebnis liefert.

Überladen von Template-Funktionen[Bearbeiten]

Ein Template ist in der Regel eine Vorlage für Funktionen, deren Parameter sich lediglich im Typ unterscheiden. Das Überladen von Funktionen ist aber auch durch eine andere Parameterzahl oder eine andere Anordnung der Parametertypen möglich. Unter dieser Überschrift wird die maxi()-Template um einen optionalen dritten Parameter erweitert. Was bisher vorgestellt wurde, wird in diesem Beispielprogramm zusammengefasst:

Nuvola-inspired-terminal.svg
 1 #include <iostream>          // Ein und Ausgabe
 2 #include <string>            // C++-Strings
 3 #include <cstring>           // Vergleiche von C-Strings
 4 
 5 using namespace std;
 6 
 7 // Unsere Standardvorlage für maxi()
 8 template <typename T>
 9 T maxi(T obj1, T obj2){
10     if(obj1 > obj2)
11         return obj1;
12     else
13         return obj2;
14 }
15 
16 // Die Spezialisierungen für C-Strings
17 template <>                                           // Spezialisierung
18 const char* maxi(const char* str1, const char* str2){ // statt T, const char*
19     if(strcmp(str1, str2) > 0)
20         return str1;
21     else
22         return str2;
23 }
24 
25 int main(){
26     int    a = 3;                         // Ganzzahlige Variable
27     double b = 5.4;                       // Gleitkommazahl-Variable
28 
29     int    m;                             // Ganzzahl-Ergebnis
30     double n;                             // Kommazahl-Ergebnis
31 
32     // Je nachdem, wo die Typumwandlungen stattfinden,
33     // sind die Ergebnisse unterschiedlich
34     m = maxi<int>(a, b);                  // m == 5
35     n = maxi<int>(a, b);                  // n == 5.0
36     m = maxi<double>(a, b);               // m == 5
37     n = maxi<double>(a, b);               // n == 5.4
38 
39     // Aufgerufen wird unabhänngig vom Ergebnistyp m:
40     m = maxi(3, 6);                       // maxi<int>()
41     m = maxi(3.0, 6.0);                   // maxi<double>()
42     m = maxi<int>(3.0, 6);                // maxi<int>()
43     m = maxi<double>(3, 6.0);             // maxi<double>()
44 
45     // Aufruf von maxi<std::string>()
46     string s1("alpha");
47     string s2("omega");
48     string smax = maxi(s1,s2);           // smax == omega
49 
50     // Aufruf von maxi<const char*>()
51     smax = maxi("alpha", "omega");        // Spezialisierung wird aufgerufen
52 
53     return 0;                            // Programm erfolgreich durchlaufen
54 }

Eine Ausgabe enthält das Programm noch nicht, aber das sollten Sie ja problemlos schaffen. Die Datei iostream ist auch schon inkludiert.

Nun aber zur Überladung der Templatefunktion: um von maxi() zu verlangen, den größten von drei Werten zurückzugeben, muss der Parameterliste ein weiterer Platzhalter, also noch ein T obj3 hinzugefügt werden. Gleiches gilt für unsere C-String-Spezialisierung. Da wir ja aber auch die Möglichkeit haben wollen, nur den größeren von zwei Werten zu bestimmen, müssen wir die bisherige Variante stehen lassen und die mit drei Argumenten hinzufügen. Das Ganze sieht dann so aus:

Nuvola-inspired-terminal.svg
 1 #include <iostream>          // Ein und Ausgabe
 2 #include <string>            // C++-Strings
 3 #include <cstring>           // Vergleiche von C-Strings
 4 
 5 using namespace std;
 6 
 7 // Unsere Standardvorlage für maxi() mit 2 Argumenten
 8 template <typename T>
 9 T maxi(T obj1, T obj2){
10   if (obj1 > obj2)
11     return obj1;
12   else
13     return obj2;
14 }
15 
16 // Die Spezialisierungen für C-Strings mit zwei Argumenten
17 template <> // Spezialisierung
18 const char* maxi(const char* str1, const char* str2){
19     if(strcmp(str1, str2) > 0)
20         return str1;
21     else
22         return str2;
23 }
24 
25 // Unsere Standardvorlage für maxi() mit drei Argumenten
26 template <typename T>
27 T maxi(T obj1, T obj2, T obj3){
28     if(obj1 > obj2)
29         if(obj1 > obj3)
30             return obj1;
31         else
32             return obj3;
33     else if(obj2 > obj3)
34         return obj2;
35     else
36         return obj3;
37 }
38 
39 // Die Spezialisierungen für C-Strings mit drei Argumenten
40 template <> // Spezialisierung
41 const char* maxi(const char* str1, const char* str2, const char* str3){
42     if(strcmp(str1, str2) > 0){
43         if(strcmp(str1, str3) > 0)
44             return str1;
45         else
46             return str3;
47     }
48     else if(strcmp(str2, str3) > 0)
49         return str2;
50     else
51         return str3;
52 }
53 
54 int main(){
55     cout << "Beispiele für Ganzzahlen:\n";
56     cout << "      (2, 7, 4) -> " << maxi(2, 7, 4) << endl;
57     cout << "         (2, 7) -> " << maxi(2, 7)    << endl;
58     cout << "         (7, 4) -> " << maxi(7, 4)    << endl;
59 
60     cout << "\nBeispiele für Kommazahlen:\n";
61     cout << "(5.7, 3.3, 8.1) -> " << maxi(5.7, 3.3, 8.1) << endl;
62     cout << "     (7.7, 7.6) -> " << maxi(7.7, 7.6)      << endl;
63     cout << "     (1.9, 0.4) -> " << maxi(1.9, 0.4)      << endl;
64 
65     cout << "\nBeispiele für C-Strings:\n";
66     cout << "(ghi, abc, def) -> " << maxi("ghi", "abc", "def") << endl;
67     cout << "     (ABC, abc) -> " << maxi("ABC", "abc")        << endl;
68     cout << "     (def, abc) -> " << maxi("def", "abc")        << endl;
69 
70     return 0;                            // Programm erfolgreich durchlaufen
71 }
Crystal Clear app kscreensaver.svg
Ausgabe:
 1 Beispiele für Ganzzahlen:
 2       (2, 7, 4) -> 7
 3          (2, 7) -> 7
 4          (7, 4) -> 7
 5 
 6 Beispiele für Kommazahlen:
 7 (5.7, 3.3, 8.1) -> 8.1
 8      (7.7, 7.6) -> 7.7
 9      (1.9, 0.4) -> 1.9
10 
11 Beispiele für C-Strings:
12 (ghi, abc, def) -> ghi
13      (ABC, abc) -> abc
14      (def, abc) -> def

So Sie verstanden haben, wie aus einer Template eine konkrete Funktion erzeugt wird, fragen Sie sich vielleicht, ob das wirklich so einfach ist. Glücklicherweise kann diese Frage bejaht werden. Man stellt sich einfach das Funktionstemplate als mehrere separate Funktionen vor, die durch unterschiedliche Parametertypen überladen sind und wendet dann die üblichen Regeln zur Überladung von Funktionen an. Wenn man, wie in diesem Fall getan, ein weiteres Funktionstemplate anlegt, werden dadurch natürlich auch gleich wieder eine ganze Reihe einzelner Funktionen hinzugefügt. Im Endeffekt überlädt man also nicht das Template, sondern immer noch die aus ihm erzeugten Funktionen. Was Spezialisierungen angeht, gehören die natürlich immer zu dem Template, das eine Verbindung zu seiner semantische Parameterliste besitzt.

Templates mit mehreren Parametern[Bearbeiten]

Natürlich kann ein Template auch mehr als nur einen Templateparameter übernehmen. Nehmen Sie an, Sie benötigen eine kleine Funktion, welche die Summe zweier Argumente bildet. Über den Typ der Argumente wissen Sie nichts, aber der Rückgabetyp ist Ihnen bekannt. Eine solche Funktion könnte folgendermaßen implementiert werden:

Nuvola-inspired-terminal.svg
 1 #include <iostream>          // Ein und Ausgabe
 2 
 3 using namespace std;
 4 
 5 // Unsere Vorlage für die Summenberechnung
 6 template <typename R, typename Arg1, typename Arg2>
 7 R summe(Arg1 obj1, Arg2 obj2){
 8     return obj1 + obj2;
 9 }
10 
11 int main(){
12     double a = 5.4;                      // Gleitkommazahl-Variable
13     int   b = -3;                       // Ganzzahlige Variable
14 
15     cout << summe<int>(a, b)             << endl; // int           summe(double obj1, int obj2);
16     cout << summe<double>(a, b)           << endl; // double       summe(double obj1, int obj2);
17     cout << summe<double>(a, b)          << endl; // double        summe(double obj1, int obj2);
18     cout << summe<unsigned long>(a, b)   << endl; // unsigned long summe(double obj1, int obj2);
19 
20     cout << summe<double, int, int>(a, b) << endl; // double         summe(int  obj1, int obj2);
21 
22     cout << summe<double, long>(a, b)     << endl; // double         summe(long obj1, int obj2);
23 
24     return 0;                            // Programm erfolgreich durchlaufen
25 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 2
2 2.4
3 2.4
4 2
5 2
6 2

Beim fünften Aufruf sind alle Argumente explizit angegeben. Wie Sie unschwer erkennen werden, kann der Compiler bei dieser Funktion den Rückgabetyp nicht anhand der übergebenen Funktionsparameter ermitteln. Daher müssen Sie ihn immer explizit angeben, wie die ersten vier Aufrufe es zeigen.

Die Templateargumente werden beim Funktionsaufruf in der gleichen Reihenfolge angegeben, wie sie bei der Deklaraton des Templates in der Templateargumentliste stehen. Wenn dem Compiler weniger Argumente übergeben werden als bei der Deklaration angegeben, versucht er die übrigen anhand der Funktionsargumente zu bestimmen.

Das bedeutet für Sie, dass Argumente, die man immer explizit angeben muss, auch bei der Deklaration an vorderster Stelle der Templateargumentliste stehen müssen. Das folgende Beispiel verdeutlicht die Folgen bei Nichteinhaltung dieser Regel:

Crystal Clear action button cancel.svg
 1 #include <iostream>          // Ein und Ausgabe
 2 
 3 using namespace std;
 4 
 5 // Unsere Vorlage für die Summenberechnung
 6 template <typename Arg1, typename Arg2, typename R> // Rückgabetyp als letztes angegeben
 7 R summe(Arg1 obj1, Arg2 obj2){
 8     return obj1 + obj2;
 9 }
10 
11 int main(){
12     double a = 5.4;                       // Gleitkommazahl-Variable
13     int   b = -3;                        // Ganzzahlige Variable
14 
15     cout << summe<int>(a, b) << endl; // ??? summe(int obj1, int  obj2);
16     cout << summe<double>(a, b) << endl; // ??? summe(double obj1, int  obj2);
17     cout << summe<double>(a, b) << endl; // ??? summe(double obj1, int  obj2);
18     cout << summe<unsigned long>(a, b) << endl; // ??? summe(unsigned long obj1, int  obj2);
19 
20     cout << summe<double, int, int>(a, b) << endl; // int summe(double obj1, int  obj2);
21 
22     cout << summe<double, long>(a, b) << endl; // ??? summe(double obj1, long obj2);
23 
24     return 0;                            // Programm erfolgreich durchlaufen
25 }

Nur der Aufruf (Nr. 5), bei dem auch das letzte Templateargument, also der Rückgabetyp explizit angegeben wurde, ließe sich übersetzen. Alle anderen bemängelt der Compiler. Sie müssten also alle Templateargumente angeben, um den Rückgabetyp an den Compiler mitzuteilen. Das schmeißt diese wundervolle Gabe des Compilers, selbständig anhand der Funktionsparameter die richtige Templatefunktion zu erkennen, völlig über den Haufen. Hinzu kommt in diesem Beispiel noch, dass die Reihenfolge bei einer expliziten Templateargumentangabe alles andere als intuitiv ist.

Nichttypargumente[Bearbeiten]

Neben Typargumenten können Templates auch ganzzahlige Konstanten als Argument übernehmen. Die folgende kleine Templatefunktion soll alle Elemente eines Arrays (Datenfeldes) beliebiger Größe mit einem Startwert initialisieren.

Nuvola-inspired-terminal.svg
1 #include <cstddef>          // Für den Typ size_t
2 
3 template <std::size_t N, typename T>
4 void array_init(T (&array)[N], T const &startwert){
5     for(std::size_t i=0; i!=N; ++i)
6         array[i]=startwert;
7 }

Die Funktion übernimmt eine Referenz auf ein Array vom Typ T mit N Elementen. Jedem Element wird der Wert zugewiesen, welcher der Funktion als Zweites übergeben wird. Der Typ std::size_t wird übrigens von der C++-Standardbibliothek zur Verfügung gestellt. Er ist in der Regel als typedef auf unsigned long deklariert.

Ihr Compiler sollte in der Lage sein, sowohl den Typ T als auch die Größe des Arrays N selbst zu ermitteln. In einigen Fällen kann es jedoch vorkommen, dass der Compiler nicht in der Lage ist, die Größe N zu ermitteln. Da sie als erstes Templateargument angegeben wurde, reicht es aus, nur sie explizit anzugeben und den Compiler in diesen Fällen zumindest den Typ T selbst ermitteln zu lassen.

inline[Bearbeiten]

Obwohl Funktionstemplates im Header definiert werden müssen, sind sie nicht automatisch auch inline. Wenn Sie eine Funktionstemplate als inline deklarieren möchten, geben Sie das Schlüsselwort zwischen Templateparameterliste und dem Prototypen an.

Klassentemplates [Bearbeiten]

Wie bereits erwähnt, lassen sich auch Klassen als Template (oder Mustervorlage) definieren. Im Gegensatz zu Funktionen ist für Klassen überhaupt keine Überladung möglich. Schließlich hat der Compiler bei Klassen keine Parameter oder ähnliches, anhand dessen er die gemeinte Klasse erkennen könnte. Somit müssen bei der Konkretisierung eines Templatetyps alle Parametertypen bzw. Werte explizit angegeben werden. Die Parameter des Konstruktors können übrigens auch nicht zum Erkennen der Templateparameter herangezogen werden, da es mehrere Konstruktoren geben kann und diese obendrein ihrerseits Funktionstemplates sein können.

Crystal Project Tutorials.png
Syntax:
template < «Templateparameterliste» >
class «Klassenname»{
    // Definition
};

//----

Templateparameterliste: «Listeneintrag», «Templateparameterliste»
Templateparameterliste: «Leere Liste»

Listeneintrag: typename «Platzhaltername»
Listeneintrag: class «Platzhaltername»
Listeneintrag: «Ganzzahliger Typ» «Platzhaltername»
«Nicht-C++-Code», »optional«

Praktische Beispiele[Bearbeiten]

Zunächst werden wir uns ein einfaches Klassentemplate ansehen:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 template < typename T1, typename T2, typename T3 >
 4 class Klasse{
 5 public:
 6     Klasse(T1 t1, T2 t2, T3 t3):
 7         t1_(t1), t2_(t2), t3_(t3)
 8     {
 9         std::cout << t1_ << '\n' << t2_ << '\n' << t3_ << std::endl;
10     }
11 
12     T1 getFirst(){ return t1_; }
13 
14 private:
15     T1 t1_;
16     T2 t2_;
17     T3 t3_;
18 };

Nun können wir unser Klassentemplate verwenden. Durch die Angabe konkreter Templateparameter konkretisieren wir unseren Typ. Anschließend können wir unsere Variable verwenden, wie jede andere auch.

Nuvola-inspired-terminal.svg


1 int main(){
2     // Konkretisierung,                 Initialisierung
3     Klasse< double, char, char const* > object(3.141, 'c', "Toll!!!");
4 
5     std::cout << "T1 ist: " << object.getFirst() << std::endl;
6 }

Analog zu Funktionstemplates lassen sich natürlich auch bei Klassentemplates neben Typparametern Ganzzahlparameter verwenden. Außerdem kann mittels typedef jederzeit ein neuer Name für einen konkretisierten Templatetyp erzeugt werden. Das nächste Beispiel wird beides demonstrieren:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 template < std::size_t N, typename T >
 4 class Array{
 5 public:
 6     Array(){
 7         for(std::size_t i = 0; i < N; ++i){
 8             values_[i] = i;
 9         }
10     }
11 
12     T& operator[](std::size_t i){ return values_[i % N]; }
13 
14 private:
15     T values_[N];
16 };
17 
18 int main(){
19     typedef Array< 3, int > Array3Int; // Konkretisierung
20     Array3Int object;
21 
22     for(std::size_t i = 0; i < 5; ++i){
23         std::cout << object[i] << std::endl;
24     }
25     std::cout << std::endl;
26 
27     object[4] = 500; // Identisch mit object[1] = 500; wegen 4 % 3 == 1
28     for(std::size_t i = 0; i < 3; ++i){
29         std::cout << object[i] << std::endl;
30     }
31 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 0
2 1
3 2
4 0
5 1
6 
7 0
8 500
9 2

Diese typedef-Technik findet auch in der Standardbibliothek viele Anwendungen. Die folgende kurze Liste zeigt einige Beispiele aus der Standardbibliothek:

Nuvola-inspired-terminal.svg
1 typedef basic_string< char >           string;
2 typedef basic_string< wchar_t >        wstring;
3 typedef basic_ostream< char >          ostream;
4 typedef basic_iofstream< char >        iofstream;
5 typedef basic_istringstream< wchar_t > wistringstream;

Standardparameter[Bearbeiten]

Analog zu Standardparametern für Funktionen können auch für Templates Standardparameter angegeben werden. Die Regeln sind dabei ebenfalls analog zu Funktionen: jeder Parameter, der über einen Standard-Typ/-Wert verfügt, muss entweder ganz rechts stehen oder auf der rechten Seite einen Nachbarn besitzen, der ebenfalls über einen Standard-Typ/-Wert verfügt. Somit müssen Parameter, die in den meisten Fällen gleich sind, nicht bei der Konkretisierung des Templates angeben werden. In den Fällen, wo dann doch mal ein anderer Typ/Wert angegeben werden muss, ist dies jedoch weiterhin problemlos möglich. Wichtig ist, dass die Parameter, die links vom Aktuellen stehen, im Standardparameter verwendet werden können.

Nuvola-inspired-terminal.svg
1 template < typename T, char = 'N' >
2 class A{};
3 
4 template < typename T1 = A< char >, typename T2 = T1*, char N = 'A', typename T3 = A< T1, N > >
5 class B{};

Auch von dieser Technik macht die Standardbibliothek reichlich Gebrauch. Einige Beispiele sind:

Nuvola-inspired-terminal.svg
1 template < typename charT, typename traits = char_traits< charT >, typename Allocator = allocator< charT > > class basic_string;
2 
3 template < typename T, typename Container = deque< T > > class queue;
4 
5 template < typename charT, typename traits = char_traits< charT > > class basic_iostream;

Spezialisierung[Bearbeiten]

Klassentemplates lassen sich ebenso spezialisieren wie Funktionstemplates. Sie lassen sich jedoch, wie schon erwähnt, im Gegensatz zu diesen nicht Überladen. Die Syntax für eine Spezialisierung sieht folgendermaßen aus:

Crystal Project Tutorials.png
Syntax:
template < «Templateparameterliste» >
class «Klassenname» < «Konkretisierung» >{
    // Definition
};

//----

Templateparameterliste: «Listeneintrag», «Templateparameterliste»
Templateparameterliste: «Leere Liste»

Listeneintrag: typename «Platzhaltername»
Listeneintrag: class «Platzhaltername»
Listeneintrag: «Ganzzahliger Typ» «Platzhaltername»
«Nicht-C++-Code», »optional«

In der „Templateparameterliste“ können hier wiederum Platzhalter angegeben werden, die dann in der Konkretisierung verwendet werden können. Wenn ein Template spezialisiert wurde, wird die am besten passende Spezialisierung verwendet. Das folgende Beispiel wird dies demonstrieren, indem im Konstruktor je nach Spezialisierung ein anderer Text ausgegeben wird. Statt des Schlüsselwortes class wird in diesem Beispiel struct verwendet, was uns das public: vor dem Konstruktor erspart.

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 template < typename T >
 4 struct A{
 5     A(){ std::cout << "A< T >" << std::endl; }
 6 };
 7 
 8 template < typename T >
 9 struct A< T* >{
10     A(){ std::cout << "A< T* >" << std::endl; }
11 }; // Spezialisierung für alle Zeiger
12 
13 template <>
14 struct A< int* >{
15     A(){ std::cout << "A< int* >" << std::endl; }
16 }; // Spezialisierung für Zeiger auf int
17 
18 template <>
19 struct A< double >{
20     A(){ std::cout << "A< double >" << std::endl; }
21 }; // Spezialisierung für double
22 
23 template < typename T >
24 struct A< T const >{
25     A(){ std::cout << "A< T const >" << std::endl; }
26 }; // Spezialisierung für alle Konstanten
27 
28 template < typename Result, typename T1, typename T2 >
29 struct A< Result (*)(T1, T2) >{
30     A(){ std::cout << "Result (*)(T1, T2)" << std::endl; }
31 }; // Spezialisierung für Zeiger auf Funktionen mit 2 Parametern
32 
33 template < typename Result >
34 struct A< Result (*)(char, double) >{
35     A(){ std::cout << "Result (*)(char, double)" << std::endl; }
36 }; // Spezialisierung für Zeiger auf Funktionen mit den Parametertypen char und double
37 
38 int main(){
39     A< char >   a; // A< T >
40     A< int >    b; // A< T >
41     A< double > c; // A< double >
42 
43     A< char* >   d; // A< T* >
44     A< int* >    e; // A< int* >
45     A< double* > f; // A< T* >
46 
47     A< char const >   g; // A< T const >
48     A< int const >    h; // A< T const >
49     A< double const > i; // A< T const >
50 
51     A< char* const >   j; // A< T const >
52     A< int* const >    k; // A< T const >
53     A< double* const > l; // A< T const >
54 
55     A< char const* >   m; // A< T* >
56     A< int const* >    n; // A< T* >
57     A< double const* > o; // A< T* >
58 
59     A< int  (*)(char, double) >               p; // Result (*)(char, double)
60     A< void (*)(long const**const, float[]) > q; // Result (*)(T1, T2)
61     A< void (*)(int) >                        r; // A< T* >
62 }

Anhand der Ausgabe beim Konstruktoraufruf lässt sich sehr schön erkennen, welche Spezialisierung der Compiler als am passendsten auserkoren hat. Die Kommentare entsprechen der Ausgabe bei der jeweiligen Zeile. Wenn Sie die Beispiele mal selbst genau unter die Lupe nehmen, werden Sie feststellen, dass sich die Wahl des Compilers leicht nachvollziehen lässt. Werden in einer Spezialisierung keine Platzhalter benötigt, wie hier zwei Mal zu sehen, muss dennoch eine leere Parameterliste angegeben werden, damit der Compiler weiß, dass es sich um eine Spezialisierung eines vorhanden Templates handelt.

Ein Beispiel für Spezialisierung in der Standardbibliothek ist vector< bool >. In den meisten Fällen wird es nicht nötig sein, eine Templateklasse zu überladen, sofern Sie diese als Verallgemeinerung einer gewöhnlichen Klasse schreiben. Sie werden jedoch später noch einiges über Template-Meta-Programmierung lernen, und dabei ist Spezialisierung extrem häufig notwendig. Klassen dienen bei dieser Programmiertechnik meist nur als Hilfsmittel, womit sie also nicht im herkömmlichen Sinne verwendet werden. Dies ist jedoch eine fortgeschrittene C++-Technik.

Definition von Membern[Bearbeiten]

Bisher war der einzige Klassenmember, den wir definiert haben, der Konstruktor. Natürlich ergibt es selten Sinn, derartige Templates zu schreiben. Daher wenden wir uns als Nächstes der Deklaration und Definition von einfachen Membervariablen und Methoden zu. Die Deklaration erfolgt wie in einer gewöhnlichen Klasse. Bei unseren Konstruktorbeispielen haben wir bereits gesehen, dass Methoden, wie auch bei gewöhnlichen Klassen, innerhalb der Klassentemplatedefinition gemacht werden können. Für alle Memberdefinitionen außerhalb der Templateklassendefinition gelten etwas andere Regeln, als bei gewöhnlichen Klassen. Da die Templateparameter des Klassentemplates dort nicht zur Verfügung stehen, müssen Sie erneut angegeben werden. Insbesondere muss nicht nur der Klassenname (getrennt durch den Bereichsoperator ::) vor dem Membernamen angegeben werden, sondern eben auch alle Parameter, die zum Klassentemplate gehören.

Crystal Project Tutorials.png
Syntax:
// (statische) Variablen
template < «Templateparameterliste» >
«Typ» «Klassenname»< «Konkretisierung» >::«Membername»(«Wert»);

// Methoden
template < «Templateparameterliste» >
«Rückgabetyp» «Klassenname»< «Konkretisierung» >::«Membername»(«Funktionsparameter»){
    // Definition
}

//----

Templateparameterliste: «Listeneintrag», «Templateparameterliste»
Templateparameterliste: «Leere Liste»

Listeneintrag: typename «Platzhaltername»
Listeneintrag: class «Platzhaltername»
Listeneintrag: «Ganzzahliger Typ» «Platzhaltername»
«Nicht-C++-Code», »optional«

Folgendes Beispiel führt einige Definitionen vor:

Nuvola-inspired-terminal.svg
 1 #include <stdexcept>
 2 
 3 template < std::size_t N, typename T >
 4 class Array{
 5 public:
 6     Array();
 7     ~Array();
 8 
 9     T& operator[](std::size_t i);
10     T& at(std::size_t i);
11 
12     static std::size_t get_count();
13 
14 private:
15     T values_[N];
16 
17     static std::size_t count;
18 };
19 
20 template < std::size_t N, typename T >
21 Array< N, T >::Array(){
22     for(std::size_t i = 0; i < N; ++i){
23         values_[i] = i;
24     }
25     ++count;
26 }
27 
28 template < std::size_t N, typename T >
29 Array< N, T >::~Array(){
30     --count;
31 }
32 
33 template < std::size_t N, typename T >
34 T& Array< N, T >::operator[](std::size_t i){
35     return values_[i % N];
36 }
37 
38 template < std::size_t N, typename T >
39 T& Array< N, T >::at(std::size_t i){
40     if(i >= N) throw std::out_of_range();
41     return operator[](i);
42 }
43 
44 template < std::size_t N, typename T >
45 std::size_t Array< N, T >::get_count(){
46     return count;
47 }
48 
49 template < std::size_t N, typename T >
50 std::size_t Array< N, T >::count = 0; // oder: count(0)

Natürlich können Sie auf diese Weise leicht einzelne Member der Klasse für beliebige Templateargumente spezialisieren. Sie müssen nur die spezialisierten Argumente in den spitzen Klammern nach dem Klassennamen angeben. Genau wie Funktionstemplates dürfen natürlich auch Member Klassentemplates nur in der aktuellen Datei definiert werden, da der Compiler bei einem Template immer die komplette Definition kennen muss.

Templatemember[Bearbeiten]

Nachdem Sie nun Funktionen und Klassen zu Templates gemacht haben, steht noch die Kombination aus beidem aus, denn auch die Methoden von Klassentemplates lassen sich natürlich als Methodentemplates schreiben. Das einzig Neue dabei ist die Definition der Methoden außerhalb der Klasse, bei der beide Templates spezifiziert werden müssen. Im Folgenden sehen Sie ein Klassentemplate, das einen Templatekonstruktor besitzt, um gleich eine ganze Anzahl von Datentypen zur Initialisierung zuzulassen.

Nuvola-inspired-terminal.svg
 1 #include <cstddef> // Für std::size_t
 2 
 3 template < std::size_t N, typename T >
 4 class Array{
 5 public:
 6     Array();
 7 
 8     template < typename Iterator >
 9     Array(Iterator iter); // Deklaration des Methodentemplates
10 
11     T& operator[](std::size_t i);
12 
13 private:
14     T values_[N];
15 };
16 
17 template < std::size_t N, typename T >
18 Array< N, T >::Array(){
19     for(std::size_t i = 0; i < N; ++i){
20         values_[i] = i;
21     }
22 }
23 
24 template < std::size_t N, typename T > // Klassentemplate
25 template < typename Iterator >         // Methodentemplate
26 Array< N, T >::Array(Iterator iter){   // Definition der Methode
27     for(std::size_t i = 0; i < N; ++i){
28         values_[i] = *iter++;
29     }
30 }
31 
32 template < std::size_t N, typename T >
33 T& Array< N, T >::operator[](std::size_t i){
34     return values_[i % N];
35 }
36 
37 #include <vector>
38 #include <list>
39 #include <iostream>
40 
41 int main(){
42     std::vector< int > a;
43     std::list< int > b;
44     int c[5];
45 
46 	for(std::size_t i = 0; i < 5; ++i){
47         a.push_back(i);
48         b.push_back(i);
49 		c[i] = i;
50 	}
51 
52     Array< 5, int > a_t(a.begin());
53     Array< 5, int > b_t(b.begin());
54     Array< 5, int > c_t(c);
55 
56 	for(std::size_t i = 0; i < 5; ++i){
57         std::cout << a_t[i] << ' ' << b_t[i] << ' ' << c_t[i] << std::endl;
58 	}
59 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 0 0 0
2 1 1 1
3 2 2 2
4 3 3 3
5 4 4 4

Wie Sie sehen, können Sie nun jeden beliebigen Datentyp für die Initialisierung verwenden, für den der Postfix-Increment- und Dereferenzierungsoperator entsprechend überladen ist. Die hier gezeigte Definition ist nicht besonders gut, da keinerlei Bereichsüberprüfung durchgeführt wird. Der Konstruktor muss sich darauf verlassen, das über den Iterator genügend gültige Elemente zur Verfügung stehen, aber es demonstriert sehr schön, welche Möglichkeiten diese Technik bietet.

Templatefreunde [Bearbeiten]

Baustelle.svg

Dieses Kapitel ist leider noch nicht vorhanden…


Wenn Sie Lust haben können Sie das Kapitel [[C++-Programmierung/ {{{Name}}}/ {{{Kapitel}}}|{{{Kapitel}}}]] selbst schreiben oder einen Beitrag dazu leisten.

Die zweite Bedeutung von typename [Bearbeiten]

Baustelle.svg

Dieses Kapitel ist leider noch nicht vorhanden…


Wenn Sie Lust haben können Sie das Kapitel [[C++-Programmierung/ {{{Name}}}/ {{{Kapitel}}}|{{{Kapitel}}}]] selbst schreiben oder einen Beitrag dazu leisten.

Templates als Templateparameter [Bearbeiten]

Baustelle.svg

Dieses Kapitel ist leider noch nicht vorhanden…


Wenn Sie Lust haben können Sie das Kapitel [[C++-Programmierung/ {{{Name}}}/ {{{Kapitel}}}|{{{Kapitel}}}]] selbst schreiben oder einen Beitrag dazu leisten.

Zusammenfassung [Bearbeiten]

Baustelle.svg

Zu diesem Abschnitt existiert leider noch keine Zusammenfassung…


Wenn Sie Lust haben können Sie die [[C++-Programmierung/ {{{Name}}}/ Zusammenfassung|Zusammenfassung zum Abschnitt {{{Name}}}]] selbst schreiben oder einen Beitrag dazu leisten.