Class template

Eine Klassenvorlage definiert eine Familie von Klassen.

Syntax

Erklärung

Klassen-Template-Instanziierung

Eine Klassenvorlage an sich ist kein Typ, kein Objekt oder eine andere Entität. Aus einer Quelldatei, die nur Vorlagendefinitionen enthält, wird kein Code generiert. Damit Code erzeugt wird, muss eine Vorlage instanziiert werden: Die Vorlagenargumente müssen bereitgestellt werden, damit der Compiler eine tatsächliche Klasse (oder Funktion, aus einer Funktionsvorlage) generieren kann.

Explizite Instanziierung

Eine explizite Instanziierungsdefinition erzwingt die Instanziierung der Klasse, Struktur oder Union, auf die sie sich bezieht. Sie kann im Programm überall nach der Template-Definition erscheinen und darf für eine gegebene argument-list nur einmal im gesamten Programm vorkommen, keine Diagnose erforderlich.

Klassen, Funktionen , Variablen (since C++14) und Spezialisierungen von Member-Templates können explizit aus ihren Templates instanziiert werden. Member-Funktionen, Member-Klassen und statische Datenelemente von Klassentemplates können explizit aus ihren Member-Definitionen instanziiert werden.

Explizite Instanziierung kann nur im umschließenden Namensraum der Vorlage erscheinen, es sei denn, sie verwendet qualifizierte ID:

namespace N
{
    template<class T>
    class Y // Template-Definition
    {
        void mf() {}
    };
}
// template class Y<int>; // Fehler: Klassen-Template Y im globalen Namespace nicht sichtbar
using N::Y;
// template class Y<int>; // Fehler: Explizite Instanziierung außerhalb
                          // des Namespaces des Templates
template class N::Y<char*>;       // OK: Explizite Instanziierung
template void N::Y<double>::mf(); // OK: Explizite Instanziierung

Explizite Instanziierung hat keine Auswirkung, wenn zuvor eine explizite Spezialisierung für denselben Satz von Template-Argumenten aufgetreten ist.

Bei der expliziten Instanziierung einer Funktionsvorlage , einer Variablenvorlage (seit C++14) , einer Elementfunktion oder statischen Elementvariable einer Klassenvorlage, oder einer Elementfunktionsvorlage muss nur die Deklaration sichtbar sein. Die vollständige Definition muss vor der expliziten Instanziierung einer Klassenvorlage, einer Elementklasse einer Klassenvorlage oder einer Elementklassenvorlage erscheinen, es sei denn, eine explizite Spezialisierung mit denselben Template-Argumenten ist zuvor erschienen.

Wenn eine Funktionsvorlage , Variablenvorlage (since C++14) , Memberfunktionsvorlage oder Memberfunktion oder statisches Datenelement einer Klassenvorlage mit einer expliziten Instanziierungsdefinition explizit instanziiert wird, muss die Vorlagendefinition in derselben Übersetzungseinheit vorhanden sein.

Wenn eine explizite Instanziierung eine Klassentemplatespezialisierung benennt, dient sie als explizite Instanziierung derselben Art (Deklaration oder Definition) für jedes ihrer nicht geerbten Nicht-Template-Member, das zuvor nicht in der Übersetzungseinheit explizit spezialisiert wurde. Wenn diese explizite Instanziierung eine Definition ist, ist sie auch nur für die Member, die zu diesem Zeitpunkt definiert wurden, eine explizite Instanziierungsdefinition.

Explizite Instanziierungsdefinitionen ignorieren Zugriffsspezifizierer von Mitgliedern: Parametertypen und Rückgabetypen können privat sein.

Implizite Instanziierung

Wenn Code in einem Kontext auf ein Template verweist, der einen vollständig definierten Typ erfordert, oder wenn die Vollständigkeit des Typs den Code beeinflusst, und dieser bestimmte Typ nicht explizit instanziiert wurde, tritt eine implizite Instanziierung auf. Zum Beispiel, wenn ein Objekt dieses Typs konstruiert wird, aber nicht, wenn ein Zeiger auf diesen Typ konstruiert wird.

Dies gilt für die Mitglieder des Klassentemplates: Solange das Mitglied nicht im Programm verwendet wird, wird es nicht instanziiert und erfordert keine Definition.

template<class T>
struct Z // Template-Definition
{
    void f() {}
    void g(); // niemals definiert
};
template struct Z<double>; // explizite Instanziierung von Z<double>
Z<int> a;                  // implizite Instanziierung von Z<int>
Z<char>* p;                // hier wird nichts instanziiert
p->f(); // implizite Instanziierung von Z<char> und Z<char>::f() erfolgt hier.
        // Z<char>::g() wird niemals benötigt und niemals instanziiert:
        // es muss nicht definiert werden

Wenn eine Klassenvorlage deklariert, aber nicht definiert wurde, zum Zeitpunkt der Instanziierung, ergibt die Instanziierung einen unvollständigen Klassentyp:

template<class T>
class X;    // Deklaration, keine Definition
X<char> ch; // Fehler: unvollständiger Typ X<char>

Schlüsselwörter

export (bis C++11) extern (seit C++11)

Siehe auch

• Template-Parameter und Argumente ermöglichen die Parametrisierung von Templates
• Funktions-Template-Deklaration deklariert ein Funktions-Template
• Template-Spezialisierung definiert ein bestehendes Template für einen spezifischen Typ
• Parameter-Packs ermöglichen die Verwendung von Typenlisten in Templates (seit C++11)