C++-Programmierung/ Templates/ Funktionstemplates

Aus Wikibooks
Zur Navigation springen Zur Suche springen


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.