Vorlagen-Spezifikation

Die template Deklaration gibt einen Satz von parametrisierten Klassen oder Funktionen an.

template < template-parameter-list > declaration

Hinweise

Die TEMPLATE-PARAMETER Liste ist eine durch Trennzeichen getrennte Liste der Vorlagenparameter Typen, die ggf. im Formular ( KlasseBezeichneroderBezeichnerin typenamein Vorlage < TEMPLATE-PARAMETER Liste >-Klasse Bezeichner) oder im Vorlagentext Nichttyp-Parameter vorgesehen sind.Die Syntax für einen Vorlagenparameter ist eine der folgenden Aktionen aus:

parameter-declaration
class identifier [ = typename ] 
typename identifier [ = typename ]
template < template-parameter-list > class [identifier][= name]

Sie können eine Klassenvorlage ähnlich wie Sie eine normale Klasse instanziieren instanziiert werden, aber Sie müssen die Vorlagenargumente in spitzen Klammern (<>) einschließen.Diese Vorlagenargumente können jeder Typ, wenn die Vorlagenargumentliste die Klasse oder das typename-Schlüsselwort enthält, oder ein Wert des entsprechenden Typs sein, wenn das Argument ein Nichttyp-Argument ist.Keine besondere Syntax ist erforderlich, um eine Funktionsvorlage aufzurufen, obwohl die spitzen Klammern und die Vorlagenargumente erforderlich sein können, wenn die Vorlagenparameter nicht von Argumenten für die Funktion abgeleitet werden können.

Die TEMPLATE-PARAMETER Liste ist eine Liste von Parametern, die von der Vorlagenfunktion verwendet werden, die angibt, welche Teile des folgenden Codes unterscheiden.Beispiele:

template< class T, int i > class MyStack...

In diesem Fall kann die Vorlage einen Typ (class T) und einen konstanten Parameter (int i) empfangen.Die Vorlage verwendet i ganzzahlige Konstante und T-Typ nach der Instanziierung.Innerhalb des Texts der MyStack Deklaration, müssen Sie den T Bezeichner verweisen.

Eine Vorlagendeklaration selbst kein Code generiert. Sie gibt eine Gruppe von Klassen oder Funktionen, von denen eine oder mehrere generiert werden, wenn sie von anderem Code verwiesen wird.

Deklarationen, globalen Vorlagen verfügen Namespace oder Klassengültigkeitsbereich.Sie können nicht innerhalb einer Funktion deklariert werden.

Das folgende Beispiel veranschaulicht die Deklaration, die Definition und Instanziierung einer Klassenvorlage mit einem Typparameter T und einem Nicht TYPE-Vorlagenparameteri.

// template_specifications1.cpp
template <class T, int i> class TestClass 
{
public:
   char buffer[i];
   T testFunc(T* p1 );
};

template <class T, int i>
T TestClass<T,i>::testFunc(T* p1) 
{
    return *(p1++)
};

// To create an instance of TestClass
TestClass<char, 5> ClassInst;
int main()
{
}

Nicht-TYPE-Vorlagenargumente

Ganze Zahlen müssen vom Nicht-TYPE-Vorlagenparameter aus der Enumeration vom Zeiger oder Verweis aus dem vom Zeiger auf den Membertyp sein und müssen zur Kompilierungszeit konstant sein.Sie können als const oder flüchtige Typen qualifiziert werden.Gleitkommawerte werden als Vorlagenparameter nicht zulässig.Objekte der Klasse, Struktur oder eines Union-Typs werden nicht als Nicht TYPE-Vorlagenparameter zulässig, obwohl Zeiger auf solche Objekte zulässig sind.Die Arrays, die als NichtTYPE-Vorlagenparameter übergeben werden, werden in Zeiger konvertiert.Die Funktionen, die als Nichttyp-Parameter übergeben werden, werden als Funktionszeiger behandelt.Zeichenfolgenliterale werden als Vorlagenparameter nicht zulässig.

Verwenden des Typnamens in einer Vorlagen-Deklaration

Das Typname-Schlüsselwort kann in der Vorlagenparameterliste verwendet werden.Die folgenden Vorlagen Deklarationen sind identisch:

template< class T1, class T2 > class X...
template< typename T1, typename T2 > class X...

Standardargumente für Vorlagenparameter

Klassenvorlagen können die Standardargumente haben, die mithilfe des angegebenen Zeichens = vom Standardtyp oder dem Wert folgen.Standardargumente können von Funktionen enthalten.Weitere Informationen finden Sie unter Standardargumente Klassenvorlagen .:

template<typename Type> class allocator {};
template<typename Type, 
   typename Allocator = allocator<Type> > class stack 
{
};
stack<int> MyStack;

Wiederverwenden von Vorlagenparametern

Vorlagenparameter können in der Vorlagenparameterliste wiederverwendet werden.Im folgenden Code wird beispielsweise zulässig:

// template_specifications2.cpp

class Y 
{
};
template<class T, T* pT> class X1 
{
};
template<class T1, class T2 = T1> class X2 
{
};

Y aY;

X1<Y, &aY> x1;
X2<int> x2;

int main()
{
}

Vorlagen als Vorlagenparameter

Vorlagenparameter machen sich Vorlagen sind.Dieses Konstrukt bedeutet, dass das Argument selbst eine Vorlage befinden muss. weder eine Klasse, die von der Vorlage erstellt wird.Im folgenden Beispiel kann der Name A des Vorlagenparameters für einen Vorlagen vorlagenparameter ausgelassen werden, da es keine Möglichkeit gibt, dass sie verwendet werden kann.

// template_specifications3.cpp
#include <stdio.h>

template <class T> struct str1
{
   T t;
};

template <template<class A> class T> struct str2
{
    T<int> t;
};

int main()
{
    str2<str1> mystr2;
    mystr2.t.t = 5;
    printf_s("%d\n", mystr2.t.t);
}

Output

5

Verweise als Vorlagenparameter

Visual Studio .NET 2003 stellt die Fähigkeit eingeführt, TYPE-Vorlagenparameter nicht als Verweise zu verwenden.Dies wurde in früheren Versionen nicht zulässig.

// references__supported_as_nontype_template_parameters.cpp
#include <stdio.h>

extern "C" int printf_s(const char*,...);
template <int & ri> struct S
{
   S()
   {
      printf_s("ri is %d\n", ri);
   }

   ~S()
   {
      printf_s("ri is %d\n", ri);
   }
};

int i = 1;

int main()
{
   S<i> s;
   i = 0;
}

Output

ri is 1
ri is 0

Geschachtelte Vorlagen-Instanzen

Versionen von Visual Studio vor erforderlichem Visual Studio 2005 mit Leerraum zwischen Vorlagenparameter listet wenn geschachtelte Vorlagen deklariert wurden, werden Instanzen eingefügt.Die folgende Syntax wird jetzt zulässig:

// template_specifications4.cpp 

template <typename T> 
class A
{
};

template <int n> 
class B 
{
};

int main() 
{
   A<B<22>>();
}

Siehe auch

Referenz

C++-Schlüsselwörter

Weitere Ressourcen

Vorlagen