C++-Templates: generische Funktionen und Klassen erklärt

Einmal schreiben, für jeden Typ verwenden

Auf der vorherigen Seite hast du einen vector<int> mit std::sort sortiert. Aber std::sort sortiert auch einen vector<string>, einen vector<double> oder ein Array deiner eigenen Structs - ohne dass jemand für jeden ein eigenes sort schreibt. Das ist weder Zauberei noch Überladung. Es ist ein Template: ein einziges Stück Code, das der Compiler für jeden Typ wiederverwendet, den du ihm gibst.

Ohne Templates müsstest du dieselbe Logik für jeden Typ per Copy-and-paste duplizieren. Hier ist dieselbe Funktion maximum dreimal geschrieben - genau die Duplizierung, die Templates beseitigen sollen:

int    maximum(int a, int b)       { return a > b ? a : b; }
double maximum(double a, double b) { return a > b ? a : b; }
string maximum(string a, string b) { return a > b ? a : b; }

Die Rümpfe sind identisch. Nur die Typen unterscheiden sich. Ein Template erlaubt dir zu sagen „das funktioniert für jeden Typ T" und es einmal zu schreiben.

Funktions-Templates

Du machst aus einer Funktion ein Template, indem du template <typename T> davorsetzt und T überall dort verwendest, wo normalerweise ein konkreter Typ stünde.

#include <iostream>
#include <string>
using namespace std;

template <typename T>
T maximum(T a, T b) {
    return a > b ? a : b;
}

int main() {
    cout << maximum(3, 7) << "\n";          // 7   (T = int)
    cout << maximum(2.5, 1.1) << "\n";      // 2.5 (T = double)
    cout << maximum(string("apple"),
                    string("banana")) << "\n"; // banana (T = string)
    return 0;
}

Beachte, dass du nie maximum<int> oder maximum<double> geschrieben hast. Der Compiler betrachtet die Argumente und ermittelt, was T sein soll - das ist die Template-Argument-Deduktion. Jeder unterschiedliche Typ, mit dem du sie aufrufst, veranlasst den Compiler, hinter den Kulissen eine separate konkrete Funktion zu instanziieren (zu erzeugen).

Du kannst den Typ explizit angeben, wenn die Deduktion nicht helfen kann, indem du spitze Klammern verwendest:

#include <iostream>
using namespace std;

template <typename T>
T zero() {            // nichts zu deduzieren - keine Argumente
    return T{};
}

int main() {
    cout << zero<int>() << "\n";     // 0
    cout << zero<double>() << "\n";  // 0
    return 0;
}

In der Deduktion lauert eine häufige Falle. Da T ein einzelner Typ sein muss, bricht das Mischen von Argumenttypen sie:

maximum(3, 7.5);   // FEHLER: Ist T int oder double? Der Compiler weigert sich zu raten.

Du kannst das beheben, indem du explizit bist - maximum<double>(3, 7.5) - oder indem du jedem Parameter seinen eigenen Typparameter gibst, was wir als Nächstes tun.

Mehrere Typparameter

Ein Template ist nicht auf einen Typ beschränkt. Liste so viele auf, wie du brauchst, durch Kommas getrennt. So schreibst du eine Funktion, deren Parameter unterschiedliche Typen haben können:

#include <iostream>
#include <string>
using namespace std;

template <typename A, typename B>
void printPair(A first, B second) {
    cout << first << " -> " << second << "\n";
}

int main() {
    printPair(1, "one");        // A = int, B = const char*
    printPair(3.14, true);      // A = double, B = bool
    printPair("pi", 3.14159);   // A = const char*, B = double
    return 0;
}

Wenn der Rückgabetyp von den Parametern abhängt, lass den Compiler ihn mit auto ermitteln (C++14 und später), das sich natürlich mit Templates verbindet:

#include <iostream>
using namespace std;

template <typename A, typename B>
auto add(A a, B b) {
    return a + b;   // Rückgabetyp aus a + b abgeleitet
}

int main() {
    cout << add(2, 3) << "\n";     // 5    (int + int)
    cout << add(2, 3.5) << "\n";   // 5.5  (int + double -> double)
    return 0;
}

Klassen-Templates

Templates sind nicht nur für Funktionen da - ganze Klassen können als Template definiert werden. Genau so funktionieren die Standardcontainer: vector<int>, die Schlüssel-Wert-map und pair<A, B> sind allesamt Klassen-Templates. Du schreibst die Datenstruktur einmal, und sie speichert den Typ, mit dem du sie parametrisierst.

Hier ist eine winzige generische Box, die einen Wert beliebigen Typs hält:

#include <iostream>
#include <string>
using namespace std;

template <typename T>
class Box {
    T value;
public:
    Box(T v) : value(v) {}
    T get() const { return value; }
    void set(T v) { value = v; }
};

int main() {
    Box<int> intBox(42);
    Box<string> wordBox("hello");

    cout << intBox.get() << "\n";   // 42
    cout << wordBox.get() << "\n";  // hello

    intBox.set(100);
    cout << intBox.get() << "\n";   // 100
    return 0;
}

Der entscheidende Unterschied zu Funktions-Templates: Bei einem Klassen-Template musst du den Typ normalerweise in spitzen Klammern angeben - Box<int> - weil es in älteren Standards keine Konstruktorargumente gibt, aus denen man ihn ableiten könnte. (C++17 fügte die Klassen-Template-Argument-Deduktion hinzu, sodass auch Box b(42); funktioniert, aber explizit zu sein ist immer sicher und liest sich klar.)

Die Fehler werden gewaltig sein - hier ist der Grund

Das ist der Teil, an dem alle stolpern, deshalb sagen wir es ganz deutlich. Ein Template wird erst vollständig geprüft, wenn es mit einem echten Typ instanziiert wird. Du kannst ein Template schreiben, das < verwendet, und es kompiliert für sich allein einwandfrei - der Fehler erscheint erst in dem Moment, in dem du es mit einem Typ instanziierst, der kein < hat.

template <typename T>
T maximum(T a, T b) {
    return a > b ? a : b;   // erfordert, dass T > unterstützt
}

struct Point { int x, y; };

// maximum(Point{1,2}, Point{3,4});
// FEHLER: kein operator > für Point. Die Meldung nennt Point UND
// zitiert diese ganze Funktion, oft über viele Zeilen hinweg.

Da der Compiler den vollständigen Typ in das Template einsetzt und Fehler aus dem Inneren des erzeugten Codes meldet, kann ein einziger Fehler eine Wand aus Ausgabe erzeugen, die Bibliotheks-Interna erwähnt. Zwei Überlebenstipps:

• Lies die erste Fehlermeldung, nicht die letzte. Spätere Fehler sind meist Folgeerscheinungen des ersten.
• Durchsuche die Meldung nach dem Namen deines eigenen Typs (hier Point). Das sagt dir, welche Instanziierung schiefgegangen ist.

Die eigentliche Lösung besteht darin, sicherzustellen, dass dein Typ alles unterstützt, was das Template braucht - für maximum heißt das, Point durch das Überladen von operator> zu erweitern, was Thema einer späteren Seite ist. Die Concepts des modernen C++20 können diese Fehler nach vorne verlagern und lesbar machen, aber das darunterliegende Substitutionsmodell bleibt dasselbe.

Weiter: Klassen

Du hast gerade ein Box-Klassen-Template gebaut - eine Klasse mit privaten Daten, einem Konstruktor und Methoden - während der Fokus auf den Templates lag. Die nächste Seite wird langsamer und vermittelt Klassen richtig: wie man Daten mit den Funktionen bündelt, die auf ihnen operieren, was public und private wirklich steuern und wie Methoden auf den eigenen Zustand des Objekts zugreifen. Templates und Klassen werden in echtem C++ ständig kombiniert, daher macht ein solides Verständnis von Klassen das Schreiben von generischem Code weit einfacher.