interface class (Komponentenerweiterungen für C++)

Deklariert eine Schnittstelle.Weitere Informationen über systemeigene Schnittstellen finden Sie unter __interface.

Alle Laufzeiten

Syntax

interface_access interface class  name :  inherit_access base_interface {};
interface_access interface struct name :  inherit_access base_interface {};

Parameter

• interface_access
  Der Zugriff auf einer Schnittstelle außerhalb der Assembly.Mögliche Werte sind public und private.Standardmäßig ist private festgelegt.Geschachtelte Schnittstellen können nicht interface_access einen Bezeichner haben.

• Name
  Der Name der Schnittstelle.

• inherit_access
  Die Barrierefreiheit von base_interface.Die einzige zulässige Barrierefreiheit für eine Basisschnittstelle ist public (Standardeinstellung).

• base_interface (optional)
  Eine Basisschnittstelle für Name-Schnittstelle.

Hinweise

interface struct ist mit interface class.

Eine Schnittstelle kann Deklarationen für Funktionen, Ereignisse und Eigenschaften enthalten.Alle öffentlichen Zugriff Schnittstellenmember verfügen.Eine Schnittstelle kann statische Datenmember, Funktionen, Eigenschaften und Ereignisse enthalten. Bei statischen Member müssen in der Schnittstelle definiert werden.

Eine Schnittstelle definiert, wie eine Klasse kann implementiert wird.Eine Schnittstelle ist keine Klasse und Klassen können nur Schnittstellen implementieren.Wenn eine Klasse eine Funktion definiert, die in einer Schnittstelle deklariert wurde, wird die Funktion implementiert, nicht außer Kraft gesetzt.Deshalb beinhaltet der Suche nach dem Namen nicht Schnittstellenmember.

Eine Klasse oder Struktur, die von einer Schnittstelle abgeleitet wird, müssen alle Member der Schnittstelle implementieren.Wenn Sie Schnittstellennamen implementieren, müssen Sie die Schnittstellen in der Liste base_interface ebenfalls implementieren.

Weitere Informationen finden Sie unter:

• Schnittstellen-statischer Konstruktor

• Generische Schnittstellen (Visual C++)

Weitere Informationen über andere CLR-Typen finden Sie unter Klassen und Strukturen.

Sie können zur Kompilierzeit erkennen, wenn ein Typ eine Schnittstelle mit __is_interface_class(type) ist.Weitere Informationen finden Sie unter Compilerunterstützung für Typmerkmale (Komponentenerweiterungen für C++).

In der Entwicklungsumgebung können Sie die F1-Hilfe für diesen Schlüsselwörtern abrufen, indem Sie das Schlüsselwort interface class(z. B. markieren und F1 drücken.)

Windows-Runtime

Hinweise

(Es gibt keine Hinweise für diese Sprachfunktion, die nur für Windows gelten. Runtime)

Anforderungen

Compileroption: /ZW

Common Language Runtime

Hinweise

(Es gibt keine Hinweise für diese Sprachfunktion, die nur für die Common Language Runtime) anwenden.

Anforderungen

Compileroption: /clr

Beispiele

Beispiel

Im folgenden Codebeispiel wird veranschaulicht, wie eine Schnittstelle für das Verhalten einer Uhr definieren kann.

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

Output

Beispiel

Im folgenden Codebeispiel werden zwei Möglichkeiten veranschaulicht, Funktionen mit derselben Signatur zu implementieren, die in mehreren Schnittstellen deklariert ist und wo diese Schnittstellen durch eine Klasse verwendet werden.

// 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 {}
};

Siehe auch

Konzepte

Komponentenerweiterungen für Laufzeitplattformen