Vue d'ensemble de modèles

Les modèles, qui sont parfois appelés types paramétrables, sont des mécanismes de génération des fonctions et des classes en fonction de les paramètres de type.En utilisant des modèles, vous pouvez concevoir une même classe ou fonction qui traite les données de nombreux types, au lieu de créer une classe distincte pour chaque type.

Remarques

Par exemple, pour créer un type sécurisé fonction qui retourne le minimum deux paramètres sans modèle, vous doit écrire un ensemble de fonctions surchargées comme suit :

// what_are_templates1.cpp
// compile with: /c
// min for ints
int min( int a, int b ) {
   return ( a < b ) ? a : b;
}

// min for longs
long min( long a, long b ) {
   return ( a < b ) ? a : b;
}

// min for chars
char min( char a, char b ) {
   return ( a < b ) ? a : b;
}

En utilisant des modèles, vous pouvez réduire cette duplication à un modèle de fonction unique :

// what_are_templates2.cpp
// compile with: /c
template <class T> T min( T a, T b ) {
   return ( a < b ) ? a : b;
}

Les modèles peuvent réduire considérablement la flexibilité de taille de code source et de code augmentent sans réduire la sécurité de type.

Il existe deux principaux types de modèles : modèles de fonction et modèles de classe.dans l'exemple précédent, min est un modèle de fonction.Un modèle de classe est une classe avec un paramètre, telle que :

// what_are_templates3.cpp
template <class T> class A {
   T m_t;
   public:
      A(T t): m_t(t) {} 
      void f(T t);
};

int main() {
   A<int> a(10);
}

Les modèles sont déclarés et définis qui est comparable d'autres fonctions et classes, avec quelques différences principales.Une déclaration de modèle ne définit pas complètement une fonction ou une classe ; elle définit uniquement une structure de syntaxe pour une classe ou une fonction.Une fonction ou une classe réelle est créée à partir d'un modèle par une instanciation processus appelé.Les classes individuelles ou fonctions créées sous le nom d'instanciées.par exemple, un modèle de classe :

template <class T> struct A { . . . };

peut être utilisé pour instancier des classes pour A<int>, A<char>, A<int*>, A<MyClass*>, et ainsi de suite.

L'instanciation de classes ou de fonctions peut être effectuée explicitement ou implicitement.L'instanciation explicite est un moyen de la spécification dans le code les versions du modèle doivent être générées.L'instanciation implicite permet aux modèles à instancier autant que nécessaire au point où leur première utilisation.

Les modèles peuvent également être paramétrables par un paramètre de valeur, auquel cas le paramètre de modèle est déclaré comme le paramètre à une fonction.Vous ne pouvez pas utiliser de types à virgule flottante et les types de classe comme paramètres de valeur.

// what_are_templates4.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

template <int i> class A {
   int array[i];
public:
   A() { memset(array, 0, i*sizeof(int)); }
};

int main() {
   A<10> a;
}

Un problème courant avec les modèles est qu'elles peuvent être une solution taille unique, ce qui signifie qu'à tout le même code s'applique types.Si vous devez personnaliser le comportement du modèle pour un type particulier, vous pouvez utiliser la spécialisation.À l'aide de la spécialisation explicite, un modèle peut être spécialisé pour un type réel particulier, pas un type générique.Un modèle de classe peut également être partiellement spécialisé, il est utile si vous avez un modèle avec plusieurs paramètres de type et vous ne souhaitiez que personnaliser le comportement vis-à-vis certains mais pas tous les paramètres.une spécialisation partielle est toujours générique et a besoin de vrais arguments template pour produire une classe instanciée réelle.

Voir aussi

Autres ressources

Modèles