interface class (C++/CLI et C++/CX)

  • Article

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 en savoir plus, consultez :

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 sur ces mot clé en mettant en surbrillance les mot clé (par exempleinterface 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 {}
};

Voir aussi

Extensions de composants pour .NET et UWP