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 >optconstraint-clause-list function-definition
generic-parameter-list:
generic-parameter
generic-parameter-list , generic-parameter
generic-parameter:
attributesopt class identifier
attributesopt typename identifier
constraint-clause-list:
constraint-clause-listopt 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!