délégué (C++/CLI et C++/CX)
Déclare un type qui représente un pointeur de fonction.
Tous les runtimes
Le Windows Runtime et le Common Language Runtime prennent en charge les délégués.
Notes
delegate est un mot clé contextuel. Pour plus d’informations, consultez Mots clés contextuels.
Vous pouvez détecter, au moment de la compilation, si un type est délégué, avec le trait de type __is_delegate(). Pour plus d’informations, consultez Compiler Support for Type Traits (Prise en charge du compilateur pour les caractéristiques de type).
Windows Runtime
C++/CX prend en charge les délégués avec la syntaxe suivante.
Syntaxe
access
delegate
return-type
delegate-type-identifier
(
[ parameters ]
)
Paramètres
access
(facultatif) Accessibilité du délégué, qui peut être public (la valeur par défaut) ou private. Le prototype de fonction peut également être qualifié avec les mots clés ou volatile les const mots clés.
return-type
Le type de retour du prototype de fonction.
delegate-type-identifier
Le nom du type de délégué déclaré.
parameters
(Facultatif) Les types et identificateurs du prototype de fonction.
Notes
Utilisez delegate-type-identifier pour déclarer un événement avec le même prototype que le délégué. Pour plus d’informations, consultez Délégués (C++/CX).
Spécifications
Option du compilateur : /ZW
Common Language Runtime
Le common language runtime prend en charge les délégués avec la syntaxe suivante.
Syntaxe
access
delegate
function_declaration
Paramètres
access
(facultatif) L’accessibilité du délégué hors de l’assembly, qui peut être public ou private. La valeur par défaut est private. À l’intérieur d’une classe, un délégué peut disposer de n’importe quelle accessibilité.
function_declaration
La signature de la fonction pouvant être liée au délégué. Le type de retour d’un délégué peut être n’importe quel type managé. Pour des raisons d’interopérabilité, il est recommandé que le type de retour d’un délégué soit un type CLS.
Pour définir un délégué indépendant, le premier paramètre de function_declaration doit être le type du this pointeur de l’objet.
Notes
Les délégués sont multidiffusion : le « pointeur de fonction » peut être lié à une ou plusieurs méthodes dans une classe managée. Le mot clé delegate définit un type de délégué multidiffusion avec une signature de méthode spécifique.
Un délégué peut également être lié à une méthode d’une classe value, par exemple une méthode static.
Ce délégué présente les caractéristiques suivantes :
Hérite de
System::MulticastDelegate.Il possède un constructeur qui accepte deux arguments : un pointeur vers une classe managée ou NULL (dans le cas d’une liaison à une méthode statique) et une méthode complète du type spécifié.
Elle possède une méthode appelée
Invoke, dont la signature correspond à la signature déclarée du délégué.
Lorsqu’un délégué est appelé, sa ou ses fonctions sont appelées dans l’ordre dans lequel elles ont été attachées.
La valeur de retour d’un délégué est la valeur de retour de sa dernière fonction membre attachée.
Les délégués ne peuvent pas être surchargés.
Les délégués peuvent être dépendants ou indépendants.
Lorsque vous instanciez un délégué dépendant, le premier argument doit être une référence d’objet. Le deuxième argument d’une instanciation de délégué doit être l’adresse d’une méthode d’un objet de classe managée ou un pointeur vers une méthode de type valeur. Le deuxième argument d’une instanciation de délégué doit nommer la méthode avec la syntaxe de portée de classe complète et appliquer l’opérateur address-of.
Lorsque vous instanciez un délégué indépendant, le premier argument doit être l’adresse d’une méthode d’un objet de classe managée ou un pointeur vers une méthode de type valeur. L’argument doit nommer la méthode avec la syntaxe de portée de classe complète et appliquer l’opérateur address-of.
Lorsque vous créez un délégué pour une fonction static ou global, un seul paramètre est obligatoire : la fonction (en option, l’adresse de la fonction).
Pour plus d’informations sur les délégués, consultez
Spécifications
Option du compilateur : /clr
Exemples
L’exemple suivant montre comment déclarer, initialiser et appeler des délégués.
// mcppv2_delegate.cpp
// compile with: /clr
using namespace System;
// declare a delegate
public delegate void MyDel(int i);
ref class A {
public:
void func1(int i) {
Console::WriteLine("in func1 {0}", i);
}
void func2(int i) {
Console::WriteLine("in func2 {0}", i);
}
static void func3(int i) {
Console::WriteLine("in static func3 {0}", i);
}
};
int main () {
A ^ a = gcnew A;
// declare a delegate instance
MyDel^ DelInst;
// test if delegate is initialized
if (DelInst)
DelInst(7);
// assigning to delegate
DelInst = gcnew MyDel(a, &A::func1);
// invoke delegate
if (DelInst)
DelInst(8);
// add a function
DelInst += gcnew MyDel(a, &A::func2);
DelInst(9);
// remove a function
DelInst -= gcnew MyDel(a, &A::func1);
// invoke delegate with Invoke
DelInst->Invoke(10);
// make delegate to static function
MyDel ^ StaticDelInst = gcnew MyDel(&A::func3);
StaticDelInst(11);
}
in func1 8
in func1 9
in func2 9
in func2 10
in static func3 11