Templates

Eine Vorlage ist eine C++-Entität, die eines der folgenden Elemente definiert:

• eine Familie von Klassen ( class template ), die nested classes sein können
• eine Familie von Funktionen ( function template ), die member functions sein können

Templates werden durch einen oder mehrere Template-Parameter parametrisiert, von drei Arten: Typ-Template-Parameter, konstante Template-Parameter und Template-Template-Parameter.

Wenn Template-Argumente angegeben werden, oder, nur für Funktions- und Klassen- (seit C++17) Templates, deduziert werden, werden sie für die Template-Parameter substituiert, um eine Spezialisierung des Templates zu erhalten, das heißt einen spezifischen Typ oder einen spezifischen Funktions-Lvalue.

Spezialisierungen können auch explizit bereitgestellt werden: Vollständige Spezialisierungen sind erlaubt für Klassen- , Variablen- (seit C++14) und Funktionstemplates, Partielle Spezialisierungen sind nur für Klassentemplates und Variablentemplates (seit C++14) erlaubt.

Wenn eine Klassen-Template-Spezialisierung in einem Kontext referenziert wird, der einen vollständigen Objekttyp erfordert, oder wenn eine Funktions-Template-Spezialisierung in einem Kontext referenziert wird, der erfordert, dass eine Funktionsdefinition existiert, wird das Template instanziiert (der Code dafür wird tatsächlich kompiliert), es sei denn, das Template wurde bereits explizit spezialisiert oder explizit instanziiert. Die Instanziierung eines Klassen-Templates instanziiert keine seiner Memberfunktionen, sofern sie nicht ebenfalls verwendet werden. Zur Linkzeit werden identische Instanziierungen, die von verschiedenen Translation Units erzeugt wurden, zusammengeführt.

Die Definition eines Klassentemplates muss an der Stelle der impliziten Instanziierung sichtbar sein, weshalb Template-Bibliotheken typischerweise alle Template-Definitionen in den Headern bereitstellen (z.B., die meisten Boost-Bibliotheken sind header-only ).

Syntax

Template-Kennungen

Eine Template-Kennung hat eine der folgenden Syntaxen:

Ein einfacher Template-Bezeichner, der eine Klassentemplatespezialisierung benennt, benennt eine Klasse.

Eine Template-Kennung, die eine Alias-Template-Spezialisierung benennt, benennt einen Typ.

Eine Template-Kennung, die eine Funktionstemplatespezialisierung benennt, benennt eine Funktion.

Wenn alle folgenden Bedingungen erfüllt sind, ist eine Template-Kennung valid :

• Es gibt höchstens so viele Argumente wie Parameter oder ein Parameter ist ein Template parameter pack (since C++11) .
• Es gibt ein Argument für jeden nicht-deduzierbaren non-pack (since C++11) Parameter, der kein Standard-Template-Argument hat.
• Jedes Template-Argument passt zum entsprechenden Template-Parameter.
• Die Substitution jedes Template-Arguments in die folgenden Template-Parameter (falls vorhanden) ist erfolgreich.

Eine ungültige einfache Template-ID ist ein Kompilierzeitfehler, es sei denn, sie benennt eine Funktions-Template-Spezialisierung (in welchem Fall SFINAE anwendbar sein kann).

template<class T, T::type n = 0>
class X;
struct S
{
    using type = int;
};
using T1 = X<S, int, int>; // Fehler: zu viele Argumente
using T2 = X<>;            // Fehler: kein Standardargument für ersten Template-Parameter
using T3 = X<1>;           // Fehler: Wert 1 passt nicht zum Typ-Parameter
using T4 = X<int>;         // Fehler: Substitutionsfehler für zweiten Template-Parameter
using T5 = X<S>;           // OK

template<typename T>
concept C1 = sizeof(T) != sizeof(int);
template<C1 T>
struct S1 {};
template<C1 T>
using Ptr = T*;
S1<int>* p;                      // error: constraints not satisfied
Ptr<int> p;                      // error: constraints not satisfied
template<typename T>
struct S2 { Ptr<int> x; };       // error, no diagnostic required
template<typename T>
struct S3 { Ptr<T> x; };         // OK, satisfaction is not required
S3<int> x;                       // error: constraints not satisfied
template<template<C1 T> class X>
struct S4
{
    X<int> x;                    // error, no diagnostic required
};
template<typename T>
concept C2 = sizeof(T) == 1;
template<C2 T> struct S {};
template struct S<char[2]>;      // error: constraints not satisfied
template<> struct S<char[2]> {}; // error: constraints not satisfied

Wenn alle folgenden Bedingungen erfüllt sind, sind zwei Template-Identifikatoren gleich :

• Ihre template-name s oder Operatoren beziehen sich auf dieselbe Vorlage.
• Ihre entsprechenden Typtemplate-Argumente sind derselbe Typ.
• Die durch ihre entsprechenden konstanten Template-Argumente bestimmten Template-Parameterwerte sind template-argument-equivalent .
• Ihre entsprechenden Template-Template-Argumente beziehen sich auf dieselbe Vorlage.

Zwei Template-Bezeichner, die gleich sind, beziehen sich auf dieselbe Variable, (since C++14) Klasse oder Funktion.

Templatisierte Entität

Eine templated entity (oder in manchen Quellen "Temploid") ist jede Entität, die innerhalb einer Template-Definition definiert wird (oder für einen lambda expression erstellt) (seit C++11) wird. Alle folgenden sind templated entities:

• eine Klasse/Funktion /Variable (seit C++14) Template

• ein Mitglied einer templatisierten Entität (wie eine Nicht-Template-Memberfunktion einer Klassentemplate)
• ein Enumerator einer Enumeration, die eine templatisierte Entität ist
• jede Entität, die innerhalb einer templatisierten Entität definiert oder erstellt wird: eine lokale Klasse, eine lokale Variable, eine Friend-Funktion, etc

Zum Beispiel, in

template<typename T>
struct A
{
    void f() {}
};

die Funktion A::f ist keine Funktionsvorlage, wird jedoch weiterhin als templatisiert betrachtet.

Eine templated function ist eine Funktionsvorlage oder eine Funktion, die templated ist.

Eine templated class ist eine Klassenvorlage oder eine Klasse, die templatiert ist.

Schlüsselwörter

template , export

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Siehe auch