Caractéristiques de modèle
La déclaration d' template spécifie un ensemble de classes paramétrées ou de fonctions.
template < template-parameter-list > declaration
Notes
La liste de paramètres de modèle est une liste avec la virgule comme séparateur des paramètres de modèle, qui peuvent être des types (dansl'identificateurde classede formulaire,l'identificateurde typename, oul'identificateurde classe d'> de liste de paramètres de modèlede modèle < ) ou des paramètres de sans type à utiliser dans le corps de modèle.La syntaxe d'un paramètre de modèle est l'une des opérations suivantes :
parameter-declaration
class identifier [ = typename ]
typename identifier [ = typename ]
template < template-parameter-list > class [identifier][= name]
Vous pouvez instancier un modèle de classe comme vous instancieriez une classe normale, mais vous devez inclure les arguments template dans des crochets (<>).Ces arguments template peuvent être de tout type si la liste d'arguments template contient la classe ou le mot clé de typename , ou une valeur du type approprié si l'argument est un argument sans type.Aucune syntaxe spéciale n'est requise pour appeler un modèle de fonction, même si les crochets angulaires et les arguments template puissent être requis si les paramètres de modèle ne peuvent pas être déduits des arguments de la fonction.
La liste de paramètres de modèle est une liste de paramètres utilisés par la fonction de modèle qui spécifie les parties de code suivant varient.Par exemple :
template< class T, int i > class MyStack...
dans ce cas, le modèle peut recevoir un type (class T) et un paramètre constant (int i).Le modèle utilise le type T et i entier constante à l'instanciation.Dans le corps de la déclaration d' MyStack , vous devez faire référence à l'identificateur d' T .
Une déclaration de modèle lui-même ne génère pas de code ; elle indique une famille des classes ou des fonctions, un ou plusieurs dont est généré lorsque référencé par un autre code.
les déclarations de modèle ont global, l'espace de noms, ou la portée de classe.ils ne peuvent pas être déclarés dans une fonction.
L'exemple suivant illustre la déclaration, la définition, et instanciation d'un modèle de classe avec un paramètre de type T et un paramètreide modèle sans type.
// 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()
{
}
arguments template de sans type
les paramètres de modèle sans type doivent être de type intégral, d'énumération, de pointeur, de référence, ou de pointeur vers le type de membre, et doivent être de type au moment de la compilation.Ils peuvent être qualifiés en tant que types const ou de volatile.Vous ne pouvez pas utiliser de valeurs à virgule flottante sous forme de paramètres de modèle.Vous ne pouvez pas utiliser de objets de la classe, du struct ou du type d'union en tant que paramètres de modèle sans type, bien qu'il autorise des pointeurs à ces objets.Les tableaux sont passées comme paramètres de modèle sans type sont convertis en les pointeurs.Les fonctions passées en tant que paramètres de sans type sont traitées comme pointeurs fonction.Vous ne pouvez pas utiliser de littéraux de chaîne comme paramètres de modèle.
À l'aide de typename dans une déclaration de modèle
le mot clé de typename peut être utilisé dans la liste de paramètres de modèle.Les déclarations suivantes de modèle sont les mêmes :
template< class T1, class T2 > class X...
template< typename T1, typename T2 > class X...
Arguments par défaut pour les paramètres de modèle
Les modèles de classe peuvent avoir des arguments par défaut spécifiés à l'aide de le signe de = suivi du type par défaut ou de la valeur.Les modèles de fonction ne peuvent pas avoir d'arguments par défaut.Pour plus d'informations, consultez. Arguments par défaut pour les modèles de classe :
template<typename Type> class allocator {};
template<typename Type,
typename Allocator = allocator<Type> > class stack
{
};
stack<int> MyStack;
réutilisation des paramètres de modèle
Les paramètres de modèle peuvent être réutilisées dans la liste de paramètres de modèle.Par exemple, le code suivant :
// 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()
{
}
modèles comme paramètres de modèle
Les paramètres de modèle se peuvent être des modèles.Cet élément signifie que l'argument doit être lui-même un modèle, pas une classe construite du modèle.Dans l'exemple suivant, le nom A du paramètre de modèle pour un paramètre de modèle peut être ignoré, car il n'existe aucune façon dont elle peut être utilisée.
// 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);
}
.gif "x5w1yety.collapse_all(fr-fr,VS.110).gif")
Sortie
5
références comme paramètres de modèle
Visual Studio .NET 2003 a introduit la possibilité d'utiliser les références en tant que paramètres de modèle sans type.Cela n'était pas autorisés dans les versions antérieures.
// 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;
}
Sortie
ri is 1
ri is 0
instances imbriquées de modèle
Les versions de Visual Studio antérieures à Visual Studio 2005 requises cet espace blanc soient insérées entre les listes de paramètres de modèle lorsque des instances imbriquées de modèle a été déclarée.Il permet maintenant la syntaxe suivante :
// template_specifications4.cpp
template <typename T>
class A
{
};
template <int n>
class B
{
};
int main()
{
A<B<22>>();
}