Génériques et modèles (Visual C++)

Les génériques et les modèles sont les deux fonctionnalités de langage qui prennent en charge les types paramétrables.Toutefois, elles diffèrent et ont différentes utilisations.Cette rubrique fournit une vue d'ensemble des principales différences.

Pour plus d'informations, consultez Windows Runtime et modèles gérés (extensions du composant C++) et Vue d'ensemble de modèles.

comparer des modèles et des génériques

Différences clés entre génériques et les modèles C++ :

• Les génériques sont génériques jusqu'à ce que les types soient substitués moment de l'exécution.Les modèles sont spécifiques au moment de la compilation et ne sont pas encore de types paramétrables au moment de l'exécution

• Le common langage runtime prend en charge spécifiquement les génériques dans le code MSIL.Étant donné que le runtime sait les génériques, les types spécifiques peuvent être substitués pour les types génériques en référençant un assembly contenant un type générique.Les modèles, en revanche, résolution dans ordinaires types au moment de la compilation et les types résultante ne peuvent être spécialisés dans d'autres assemblys.

• Les génériques spécialisés dans deux assemblys différents avec les mêmes arguments de type sont du même type.Les modèles spécialisés dans deux assemblys différents avec les mêmes arguments de type sont considérés comme étant des le runtime différents types.

• Les génériques sont générés en tant que d'un seul élément de code exécutable qui est utilisé pour tous les arguments de type référence (cela ne convient pas pour les types valeur, qui ont une seule implémentation par type valeur).Le compilateur JIT sait comment les génériques et peut optimiser le code pour la référence ou des types valeur utilisés comme arguments de type.Les modèles génèrent du code d'exécution distinct pour chaque spécialisation.

• Les génériques ne permettent pas de paramètres de modèle sans type, tels qu' template <int i> C {}.les modèles les permettent.

• Les génériques ne permettent pas la spécialisation explicite (autrement dit, une implémentation personnalisée d'un modèle pour un type spécifique).les modèles font.

• les génériques ne permettent pas la spécialisation partielle (une implémentation personnalisée pour un sous-ensemble des arguments de type).les modèles font.

• les génériques ne permettent pas le paramètre de type à utiliser comme classe de base pour le type générique.les modèles font.

• paramètres de modèle-modèle de support de modèles (par exemple.template<template<class T> class X> class MyClass), mais les génériques ne stocke pas.

Combinaison des modèles et des génériques

• La différence de base dans les génériques a des conséquences pour générer des applications qui combinent des modèles et des génériques.Par exemple, supposez que vous avez une classe de modèle pour laquelle vous souhaitez créer un wrapper générique pour exposer ce modèle à d'autres langages comme génériques.Vous ne pouvez pas faire prendre le générique un paramètre de type qui il qu'il passe toutefois au modèle, étant donné que le modèle doit avoir ce paramètre de type au moment de la compilation, mais le générique ne résout pas le paramètre de type tant que le runtime.L'imbrication d'un modèle à l'intérieur d'un générique ne fonctionnera pas non plus parce qu'il n'est pas possible de développer les modèles au moment de la compilation pour les types génériques arbitraires qui peuvent être instanciés au moment de l'exécution.

Exemple

Description

l'exemple suivant montre un exemple simple des modèles et des génériques d'utilisation ensemble.Dans cet exemple, la classe de modèle passe le paramètre en type générique.l'inverse n'est pas possible.

Cet idiome peut être utilisé lorsque vous souhaitez générer sur une API générique existante par le code de modèle qui est local à un assembly de Visual C++, ou lorsque vous devez ajouter une couche de paramétrage à un type générique, pour tirer parti de certaines fonctionnalités des modèles non pris en charge par les génériques.

Code

// templates_and_generics.cpp
// compile with: /clr
using namespace System;

generic <class ItemType>
ref class MyGeneric {
   ItemType m_item;

public:
   MyGeneric(ItemType item) : m_item(item) {}
   void F() { 
      Console::WriteLine("F"); 
   }
};

template <class T>
public ref class MyRef {
MyGeneric<T>^ ig;

public:
   MyRef(T t) {
      ig = gcnew MyGeneric<T>(t);
      ig->F();
    }    
};

int main() {
   // instantiate the template
   MyRef<int>^ mref = gcnew MyRef<int>(11);
}

Sortie

F

Voir aussi

Autres ressources

Génériques (extensions du composant C++)