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

Remarques

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

Windows Runtime

Remarques

Cette fonctionnalité n’est pas prise en charge dans le 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.

Syntax

generic-declaration:
generic<generic-parameter-list>constraint-clause-listOpterfunction-definition

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

generic-parameter:
attributesOpterclassidentifier
attributesOptertypenameidentifier

constraint-clause-list:
constraint-clause-listOpterconstraint-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 le formulaire spécifié 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 ne peuvent 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 du facultatif constraint-clause-list.

generic-name
Une fonction générique peut avoir un identifier nom ou une operator fonction.

Remarques

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 , ou structdes 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 constructeur ou struct un class 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 chevrons (<>) à l’aide d’une syntaxe semblable à celle d’un appel de fonction de modèle. 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 composant pour .NET et UWP
Génériques