interface class (C++/CLI et C++/CX)
Déclare une interface. Pour plus d’informations sur les interfaces natives, consultez __interface.
Tous les runtimes
Syntaxe
interface_access interface class name : inherit_access base_interface {};
interface_access interface struct name : inherit_access base_interface {};
Paramètres
interface_access
L’accessibilité d’une interface en dehors de l’assembly. Les valeurs possibles sont public et private. private est la valeur par défaut. Les interfaces imbriquées ne peuvent pas avoir de interface_access spécificateur.
name
Nom de l’interface.
inherit_access
Accessibilité de base_interface. La seule accessibilité autorisée pour une interface de base est public (la valeur par défaut).
base_interface
(Facultatif) Interface de base pour l’interface name.
Notes
interface struct est équivalent à interface class.
Une interface peut contenir des déclarations de fonctions, d’événements et de propriétés. Tous les membres d’interface disposent d’une accessibilité publique. Une interface peut également contenir des propriétés, des événements, des fonctions et des membres de données statiques. Ces membres statiques doivent être définis dans l’interface.
Une interface définit comment une classe peut être implémentée. Une interface n’est pas une classe et les classes ne peuvent implémenter que des interfaces. Lorsqu’une classe définit une fonction déclarée dans une interface, la fonction est implémentée, et non pas remplacée. Par conséquent, la recherche de noms n’inclut pas les membres de l’interface.
Une class ou struct qui dérive d’une interface doit implémenter tous les membres de l’interface. Lors de l’implémentation de l’interface name, vous devez également implémenter les interfaces dans la base_interface liste.
Pour plus d’informations, consultez l’article suivant :
Pour plus d’informations sur les autres types CLR, consultez Classes et structs.
Au moment de la compilation, vous pouvez détecter si un type est une interface avec __is_interface_class(type). Pour plus d’informations, consultez la prise en charge du compilateur pour les caractéristiques de type.
Dans l’environnement de développement, vous pouvez obtenir de l’aide F1 sur ces mots clés en mettant en surbrillance le mot clé (par exemple interface class) et en appuyant sur F1.
Windows Runtime
Notes
(Aucune note de cette fonctionnalité de langage ne s’applique qu’au Windows Runtime.)
Spécifications
Option du compilateur : /ZW
Common Language Runtime
Notes
(Aucune note de cette fonctionnalité de langage ne s’applique qu’au Common Language Runtime.)
Spécifications
Option du compilateur : /clr
Exemples
L’exemple de code suivant montre comment une interface peut définir le comportement d’une fonction d’horloge.
// mcppv2_interface_class.cpp
// compile with: /clr
using namespace System;
public delegate void ClickEventHandler(int, double);
// define interface with nested interface
public interface class Interface_A {
void Function_1();
interface class Interface_Nested_A {
void Function_2();
};
};
// interface with a base interface
public interface class Interface_B : Interface_A {
property int Property_Block;
event ClickEventHandler^ OnClick;
static void Function_3() { Console::WriteLine("in Function_3"); }
};
// implement nested interface
public ref class MyClass : public Interface_A::Interface_Nested_A {
public:
virtual void Function_2() { Console::WriteLine("in Function_2"); }
};
// implement interface and base interface
public ref class MyClass2 : public Interface_B {
private:
int MyInt;
public:
// implement non-static function
virtual void Function_1() { Console::WriteLine("in Function_1"); }
// implement property
property int Property_Block {
virtual int get() { return MyInt; }
virtual void set(int value) { MyInt = value; }
}
// implement event
virtual event ClickEventHandler^ OnClick;
void FireEvents() {
OnClick(7, 3.14159);
}
};
// class that defines method called when event occurs
ref class EventReceiver {
public:
void OnMyClick(int i, double d) {
Console::WriteLine("OnClick: {0}, {1}", i, d);
}
};
int main() {
// call static function in an interface
Interface_B::Function_3();
// instantiate class that implements nested interface
MyClass ^ x = gcnew MyClass;
x->Function_2();
// instantiate class that implements interface with base interface
MyClass2 ^ y = gcnew MyClass2;
y->Function_1();
y->Property_Block = 8;
Console::WriteLine(y->Property_Block);
EventReceiver^ MyEventReceiver = gcnew EventReceiver();
// hook handler to event
y->OnClick += gcnew ClickEventHandler(MyEventReceiver, &EventReceiver::OnMyClick);
// invoke events
y->FireEvents();
// unhook handler to event
y->OnClick -= gcnew ClickEventHandler(MyEventReceiver, &EventReceiver::OnMyClick);
// call implemented function via interface handle
Interface_A^ hi = gcnew MyClass2();
hi->Function_1();
}
in Function_3
in Function_2
in Function_1
8
OnClick: 7, 3.14159
in Function_1
L’exemple de code suivant montre deux manières d’implémenter des fonctions avec la même signature déclarée dans plusieurs interfaces et dans l’emplacement dans lequel ces interfaces sont utilisées par une classe.
// mcppv2_interface_class_2.cpp
// compile with: /clr /c
interface class I {
void Test();
void Test2();
};
interface class J : I {
void Test();
void Test2();
};
ref struct R : I, J {
// satisfies the requirement to implement Test in both interfaces
virtual void Test() {}
// implement both interface functions with explicit overrides
virtual void A() = I::Test2 {}
virtual void B() = J::Test2 {}
};