Fonctions génériques (C++/CLI)

Une fonction générique est une fonction déclarée avec des paramètres de type. Lorsqu’elle est appelée, les types réels sont utilisés plutôt que les paramètres de type.

Toutes les plateformes

Notes

Cette fonctionnalité ne s’applique pas à toutes les plateformes.

Windows Runtime

Notes

Cette fonctionnalité n’est pas prise en charge dans Windows Runtime.

Spécifications

Non applicable.

Common Language Runtime

Une fonction générique est une fonction déclarée avec des paramètres de type générique. Lorsqu’elle est appelée, les types réels sont utilisés plutôt que les paramètres de type.

Syntaxe

generic-declaration:
  generic< generic-parameter-list > constraint-clause-list_opter function-definition

generic-parameter-list:
  generic-parameter
  generic-parameter-list , generic-parameter

generic-parameter:
  attributes_opter class identifier
  attributes_opter typename identifier

constraint-clause-list:
  constraint-clause-list_opter constraint-clause

constraint-clause:
  where identifier : constraint-item-list

constraint-item-list:
  constraint-item
  constraint-item-list , constraint-item

constraint-item:
  type-id
  ref class
  ref struct
  value class
  value struct
  gcnew ( )

generic-id:
  generic-name < generic-argument-list >

generic-name:
  identifier
  operator-function-id

generic-argument-list:
  generic-argument
  generic-argument-list , generic-argument

generic-argument:
  type-id

Paramètres

generic-parameter-list
Liste séparée par des virgules d’identificateurs de paramètre de type générique éventuellement attribués.

attributes
(Facultatif) Informations déclaratives supplémentaires. Pour plus d’informations sur les attributs et les classes d’attributs, consultez les attributs.

constraint-clause-list
Cette liste facultative spécifie des restrictions sur les types qui peuvent être utilisés comme arguments de type. Il prend la forme spécifiée dans Contraintes sur les paramètres de type générique (C++/CLI).

function-definition
Définition d’une méthode ou d’une fonction autonome. La fonction peut ne pas avoir de virtual modificateur, ce qui n’est pas autorisé, car les méthodes virtuelles peuvent ne pas être génériques. Le corps de la fonction peut faire référence aux identificateurs de paramètre de type générique. La fonction peut être une operator fonction.

generic-id
Lorsque vous appelez une instance d’une fonction générique, vous spécifiez les types utilisés pour l’implémenter dans le generic-argument-list. Cette liste correspond au generic-parameter-list, et doit satisfaire les contraintes de l’option facultative constraint-clause-list.

generic-name
Une fonction générique peut avoir un identifier nom, ou il peut s’agir d’une operator fonction.

Notes

Les fonctions génériques sont des fonctions déclarées avec un ou plusieurs paramètres de type générique. Il peut s’agir de méthodes dans une class ou struct, ou des fonctions autonomes. Une déclaration générique unique déclare implicitement une famille de fonctions qui diffèrent uniquement par la substitution d’un autre type réel au paramètre de type générique.

Un class ou struct un constructeur peut ne pas être déclaré avec des paramètres de type générique.

Lorsqu’il est appelé, le paramètre de type générique est remplacé par un type réel. Le type réel peut être spécifié explicitement entre crochets à l’aide d’une syntaxe similaire à un appel de modèle de fonction. Si la fonction est appelée sans les paramètres de type, le compilateur tente de déduire le type réel à partir des paramètres fournis dans l’appel de fonction. Le compilateur signale une erreur si l’argument de type prévu ne peut pas être déduit des paramètres utilisés.

Spécifications

Option du compilateur : /clr

Exemples

L’exemple de code suivant montre comment créer une fonction générique.

// generics_generic_function_1.cpp
// compile with: /clr
generic <typename ItemType>
void G(int i) {}

ref struct A {
   generic <typename ItemType>
   void G(ItemType) {}

   generic <typename ItemType>
   static void H(int i) {}
};

int main() {
   A myObject;

   // generic function call
   myObject.G<int>(10);

   // generic function call with type parameters deduced
   myObject.G(10);

   // static generic function call
   A::H<int>(10);

   // global generic function call
   G<int>(10);
}

Les fonctions génériques peuvent être surchargées en fonction de la signature ou de l’arité, du nombre de paramètres de type sur une fonction. En outre, les fonctions génériques peuvent être surchargées avec des fonctions non génériques du même nom, tant que les fonctions diffèrent pour certains paramètres de type. Par exemple, les fonctions suivantes peuvent être surchargées :

// generics_generic_function_2.cpp
// compile with: /clr /c
ref struct MyClass {
   void MyMythod(int i) {}

   generic <class T>
   void MyMythod(int i) {}

   generic <class T, class V>
   void MyMythod(int i) {}
};

L’exemple suivant utilise une fonction générique pour rechercher le premier élément d’un tableau. Il déclare MyClass, qui hérite de la classe de base MyBaseClass. MyClass contient une fonction générique, MyFunction, qui appelle une autre fonction générique, MyBaseClassFunction, dans la classe de base. Dans main, la fonction générique, MyFunction, est appelée à l’aide de différents arguments de type.

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

ref class MyBaseClass {
protected:
   generic <class ItemType>
   ItemType MyBaseClassFunction(ItemType item) {
      return item;
   }
};

ref class MyClass: public MyBaseClass {
public:
   generic <class ItemType>
   ItemType MyFunction(ItemType item) {
      return MyBaseClass::MyBaseClassFunction<ItemType>(item);
   }
};

int main() {
   MyClass^ myObj = gcnew MyClass();

   // Call MyFunction using an int.
   Console::WriteLine("My function returned an int: {0}",
                           myObj->MyFunction<int>(2003));

   // Call MyFunction using a string.
   Console::WriteLine("My function returned a string: {0}",
   myObj->MyFunction<String^>("Hello generic functions!"));
}

My function returned an int: 2003
My function returned a string: Hello generic functions!

Voir aussi

Extensions de composants pour .NET et UWP
Génériques