C++-Template

Dieser Artikel wurde aufgrund von inhaltlichen Mängeln auf der Qualitätssicherungsseite der Redaktion Informatik eingetragen. Dies geschieht, um die Qualität der Artikel aus dem Themengebiet Informatik auf ein akzeptables Niveau zu bringen. Hilf mit, die inhaltlichen Mängel dieses Artikels zu beseitigen und beteilige dich an der Diskussion! (+)
Begründung: Templates oder Schablonen ist nichts C++ spezifisches, das gab es bereits in VB und gibt es auch in c# und bestimmt in einigen anderen Sprachen. Der Artikel sollte dies allgemein Darstellen. --Stanze 14:45, 19. Mär. 2009 (CET)

Templates (engl.: Schablonen) sind „Programmgerüste“, die eine vom Datentyp unabhängige Programmierung ermöglichen. Templates unterstützen die generische Programmierung.

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.

In anderen Programmiersprachen gibt es ein zu Templates ähnliches Konzept unter dem Namen „generischer Typ“.

Arten von Templates

Es gibt zwei Arten von Templates in C++: Funktionstemplates und Klassentemplates.

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.

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.

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.

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
};

Teilweise Spezialisierung

Des Weiteren gibt es auch die so genannte teilweise Spezialisierung (auch partielle Spezialisierung genannt), 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.

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;
}

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;

Weiterführende Themen

• C++-Metaprogrammierung