Délégués génériques (Visual C++)
Vous pouvez utiliser des paramètres de type générique avec les délégués.Pour plus d'informations sur les délégués, consultez déléguer (extensions du composant C++).
[attributes]
generic < [class | typename] type-parameter-identifiers >
[type-parameter-constraints-clauses]
[accessibility-modifiers] delegate result-type identifier
([formal-parameters]);
Paramètres
attributes (facultatif)
les informations déclaratives supplémentaires.Pour plus d'informations sur les attributs et les classes d'attributs, consultez les attributs.type-paramètre-identificateur(s)
Liste avec la virgule comme séparateur d'identificateurs des paramètres de type.type-parameter-constraints-clauses
Prend la forme spécifié dans Contraintes sur les paramètres de type générique (C++/CLI)Accessibility-modificateurs (facultatif)
Modificateurs d'Accessibilité (par exemple.public, private).type de résultat
Type de retour du délégué.identificateur
Nom du délégué.formel-paramètres (facultatif)
La liste des paramètres du délégué.
Exemple
Les paramètres de type délégué sont spécifiés au point où un objet délégué est créé.Le délégué et la méthode associée doivent avoir la même signature.Voici un exemple d'une déclaration générique de délégué.
// generics_generic_delegate1.cpp
// compile with: /clr /c
generic < class ItemType>
delegate ItemType GenDelegate(ItemType p1, ItemType% p2);
L'exemple suivant montre que
Vous ne pouvez pas utiliser le même objet délégué avec des types construits.Créez les objets de délégué pour différents types.
Un délégué générique peut être associé à une méthode générique.
Lorsqu'une méthode générique est appelée sans spécifier des arguments de type, le compilateur tente de déduire les arguments de type pour l'appel.
// generics_generic_delegate2.cpp
// compile with: /clr
generic < class ItemType>
delegate ItemType GenDelegate(ItemType p1, ItemType% p2);
generic < class ItemType>
ref struct MyGenClass {
ItemType MyMethod(ItemType i, ItemType % j) {
return ItemType();
}
};
ref struct MyClass {
generic < class ItemType>
static ItemType MyStaticMethod(ItemType i, ItemType % j) {
return ItemType();
}
};
int main() {
MyGenClass<int> ^ myObj1 = gcnew MyGenClass<int>();
MyGenClass<double> ^ myObj2 = gcnew MyGenClass<double>();
GenDelegate<int>^ myDelegate1 =
gcnew GenDelegate<int>(myObj1, &MyGenClass<int>::MyMethod);
GenDelegate<double>^ myDelegate2 =
gcnew GenDelegate<double>(myObj2, &MyGenClass<double>::MyMethod);
GenDelegate<int>^ myDelegate =
gcnew GenDelegate<int>(&MyClass::MyStaticMethod<int>);
}
L'exemple suivant déclare un délégué générique GenDelegate<ItemType>, puis les instanciés il en l'associant à la méthode MyMethod qui utilise le paramètre de type ItemType.deux instances du délégué (un entier et un double) sont créées et appelées.
// generics_generic_delegate.cpp
// compile with: /clr
using namespace System;
// declare generic delegate
generic <typename ItemType>
delegate ItemType GenDelegate (ItemType p1, ItemType% p2);
// Declare a generic class:
generic <typename ItemType>
ref class MyGenClass {
public:
ItemType MyMethod(ItemType p1, ItemType% p2) {
p2 = p1;
return p1;
}
};
int main() {
int i = 0, j = 0;
double m = 0.0, n = 0.0;
MyGenClass<int>^ myObj1 = gcnew MyGenClass<int>();
MyGenClass<double>^ myObj2 = gcnew MyGenClass<double>();
// Instantiate a delegate using int.
GenDelegate<int>^ MyDelegate1 =
gcnew GenDelegate<int>(myObj1, &MyGenClass<int>::MyMethod);
// Invoke the integer delegate using MyMethod.
i = MyDelegate1(123, j);
Console::WriteLine(
"Invoking the integer delegate: i = {0}, j = {1}", i, j);
// Instantiate a delegate using double.
GenDelegate<double>^ MyDelegate2 =
gcnew GenDelegate<double>(myObj2, &MyGenClass<double>::MyMethod);
// Invoke the integer delegate using MyMethod.
m = MyDelegate2(0.123, n);
Console::WriteLine(
"Invoking the double delegate: m = {0}, n = {1}", m, n);
}