classe d'interface (extensions du composant C++)

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 spécificateur d' interface_access .

• name
  Nom de l'interface.

• inherit_access
  l'accessibilité de base_interface.La seule accessibilité autorisée pour une interface de base est public (valeur par défaut).

• base_interface (facultatif)
  Une interface de base pour l'interface nom.

Remarques

interface struct équivaut à interface class.

Une interface peut contenir des déclarations pour les fonctions, des événements, les propriétés et.Tous les membres d'interface ont un accès public.Une interface peut également contenir des données membres static, des fonctions, des événements, les propriétés et, et 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 peuvent uniquement implémenter des interfaces.Lorsqu'une classe définit une fonction déclarée dans une interface, la fonction est implémentée, substituée.Par conséquent, la recherche de nom n'inclut pas les membres d'interface.

Une classe ou une structure qui dérivent d'une interface doit implémenter tous les membres de l'interface.Lorsque vous implémentez le nom de l'interface vous devez également implémenter les interfaces dans base_interface liste.

Pour plus d'informations, consultez :

• Constructeur statique d'interface

• Interfaces génériques (Visual C++)

Pour plus d'informations sur les autres types CLR, consultez Classes et structures.

Vous pouvez détecter de compilation si un type est une interface avec __is_interface_class(type).Pour plus d'informations, consultez Prise en charge du compilateur pour les Type Traits (extensions du composant C++).

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é, (interface class, par exemple) et en appuyant sur F1.

Windows Runtime

Remarques

(Il n'y a aucune note pour cette fonctionnalité de langage qui s'appliquent uniquement aux fenêtres d'exécution.)

Configuration requise

Option du compilateur : /ZW

Common Language Runtime

Remarques

(Il n'y a aucune note pour cette fonctionnalité de langage qui s'appliquent uniquement au common langage runtime.)

Configuration requise

Option du compilateur : /clr

Exemples

Exemple

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();
}

Sortie

Exemple

Les exemple de code suivant montre deux façons d'implémenter des fonctions avec la même signature déclarée dans plusieurs interfaces et où 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

Concepts

Extensions de composant pour les plateformes Runtime