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

Une fonction générique est une fonction déclarée avec des paramètres de type.Lorsqu'ils sont appelés, les types réels sont utilisés au lieu de paramètres de type.

Toutes les plateformes

Remarques

Cette fonctionnalité n'applique pas à toutes les plateformes.

Windows Runtime

Remarques

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

Configuration requise

Option du compilateur : /ZW

Common Language Runtime

Une fonction générique est une fonction déclarée avec des paramètres de type.Lorsqu'ils sont appelés, les types réels sont utilisés au lieu de paramètres de type.

Syntaxe

[attributes] [modifiers]
return-type identifier <type-parameter identifier(s)>
[type-parameter-constraints clauses]

([formal-parameters])
{
   function-body
}

Paramètres

• attributs (facultatif)
  Les informations déclaratives supplémentaires.Pour plus d'informations sur les attributs et les classes d'attributs, consultez les attributs.

• modificateurs (facultatif)
  Un modificateur dans la fonction, comme rueatic. vous ne pouvez pas virtual comme les méthodes virtuelles peuvent ne pas être génériques.

• type de retour
  Type retourné par la méthode.Si le type de retour est de type void, aucune valeur de retour n'est requise.

• identificateur
  le nom de la fonction ;

• identificateurs de paramètres de type
  Liste délimitée par des virgules des identificateurs.

• formel-paramètres (facultatif)
  Liste de paramètres.

• type-paramètre-contrainte-clauses
  Cela spécifie les restrictions sur les types qui peuvent être utilisés comme arguments de type, et prend la forme spécifié dans Contraintes sur les paramètres de type générique (C++/CLI).

• corps de fonction
  Le corps de la méthode, qui peut faire référence à des identificateurs de paramètres de type.

Remarques

Les fonctions génériques sont des fonctions déclarées avec un paramètre de type générique.Ils peuvent être des méthodes dans une classe ou un struct, ou des fonctions autonomes.Une déclaration générique unique déclare implicitement une famille de fonctions qui diffèrent uniquement dans la substitution d'un type réel différent pour le paramètre de type générique.

Dans Visual C++, la classe ou les constructeurs de structure ne peut être déclarée avec paramètres de type générique.

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

Configuration requise

Option du compilateur : /clr

Exemples

Exemple

L'exemple de code suivant illustre 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);
}

Exemple

Les fonctions génériques peuvent être surchargées selon la signature ou arité, le 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 dans 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) {}
};

Exemple

L'exemple suivant utilise une fonction générique pour rechercher le premier élément dans un tableau.Elle 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!"));
}

Sortie

Voir aussi

Concepts

Extensions de composant pour les plateformes Runtime

Autres ressources

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