Megosztás a következőn keresztül:

interface class (C++/CLI és C++/CX)

Deklarál egy felületet. A natív felületekkel kapcsolatos információkért lásd: __interface.

Minden futtatókörnyezet

Szemantika

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

Paraméterek

interface_access
Egy illesztő akadálymentessége a szerelvényen kívül. A lehetséges értékek a következők: public és private. A private az alapértelmezett. A beágyazott felületek nem tartalmazhatnak interface_access meghatározót.

name
A felület neve.

inherit_access
Az akadálymentesség.base_interface Az alapillesztők számára az egyetlen engedélyezett akadálymentesség (az public alapértelmezett).

base_interface
(Nem kötelező) Az interfész namealapfelülete.

Megjegyzések

interface structegyenértékű a .-nak.interface class

Az interfészek tartalmazhatnak deklarációkat a függvényekhez, eseményekhez és tulajdonságokhoz. Minden felülettag rendelkezik nyilvános akadálymentességgel. Az interfészek statikus adattagokat, függvényeket, eseményeket és tulajdonságokat is tartalmazhatnak, és ezeket a statikus tagokat meg kell határozni a felületen.

Az interfész meghatározza az osztály implementálásának módját. A felület nem osztály, és az osztályok csak interfészeket implementálhatnak. Amikor egy osztály egy felületen deklarált függvényt határoz meg, a függvény implementálva lesz, nem felül van bírálva. Ezért a névkeresés nem tartalmazza a felület tagjait.

Egy class vagy struct egy interfészből származónak az interfész minden tagját implementálnia kell. Az interfész namemegvalósításakor a listában szereplő interfészeket base_interface is implementálnia kell.

További információkért lásd:

További információ az egyéb CLR-típusokról: Osztályok és szerkezetek.

A fordítási időpontban észlelheti, ha egy típus egy interfész.__is_interface_class(type) További információ: A fordító támogatja a típustulajdonságokat.

A fejlesztési környezetben F1-segítséget kaphat ezekhez a kulcsszavakhoz a kulcsszó (például interface class) kiemelésével és az F1 billentyű lenyomásával.

Windows futtatókörnyezet

Megjegyzések

(Ehhez a nyelvi funkcióhoz nem tartoznak megjegyzések, amelyek csak a Windows futtatókörnyezetre vonatkoznak.)

Követelmények

Fordítási lehetőség: /ZW

Common Language Runtime (Közös Nyelvi Futásidő)

Megjegyzések

(Ehhez a nyelvi funkcióhoz nincsenek megjegyzések, amelyek csak a közös nyelvi futtatókörnyezetre vonatkoznak.)

Követelmények

Fordítási lehetőség: /clr

Példák

Az alábbi kódpéldából megtudhatja, hogyan határozhatja meg egy interfész az órafüggvények viselkedését.

// 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

Az alábbi kódminta két módszert mutat be a több felületen deklarált azonos aláírással rendelkező függvények implementálására, valamint az osztály által használt felületekre.

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

Lásd még

Komponensbővítmények .NET-hez és UWP-hez

  • Last updated on