interface class (C++/CLI e C++/CX)
Declara uma interface. Confira mais informações sobre interfaces nativas em __interface.
Todos os runtimes
Sintaxe
interface_access interface class name : inherit_access base_interface {};
interface_access interface struct name : inherit_access base_interface {};
Parâmetros
interface_access
A acessibilidade de uma interface fora do assembly. Os valores possíveis são public e private. private é o padrão. As interfaces aninhadas não podem ter um especificador interface_access.
name
O nome da interface.
inherit_access
A acessibilidade de base_interface. A única acessibilidade permitida para uma interface base é public (o padrão).
base_interface
(Opcional) Uma interface base para a interface name.
Comentários
interface struct é equivalente a interface class.
Uma interface pode conter declarações para funções, eventos e propriedades. Todos os membros da interface têm acessibilidade pública. Uma interface também pode conter membros de dados estáticos, funções, eventos e propriedades, e esses membros estáticos devem ser definidos na interface.
Uma interface define como uma classe pode ser implementada. Uma interface não é uma classe, e classes só podem implementar interfaces. Quando uma classe define uma função declarada em uma interface, essa função é implementada, e não substituída. Portanto, a pesquisa de nomes não inclui membros de interface.
Um class ou struct derivado de uma interface deve implementar todos os membros da interface. Ao implementar a interface name, você também deve implementar as interfaces na lista base_interface.
Para saber mais, veja:
Confira mais informações sobre outros tipos de CLR em Classes e structs.
Em tempo de compilação, você pode detectar se um tipo é uma interface com __is_interface_class(type). Para mais informações, confira Suporte para compilador de traços de tipo.
No ambiente de desenvolvimento, é possível obter ajuda com F1 sobre essas palavras-chave, destacando a palavra-chave, (interface class, por exemplo) e pressionando F1.
Windows Runtime
Comentários
(Não há comentários para esse recurso de linguagem que se apliquem somente ao Windows Runtime.)
Requisitos
Opção do compilador: /ZW
Common Language Runtime
Comentários
(Não há comentários para esse recurso de linguagem que se apliquem apenas ao Common Language Runtime.)
Requisitos
Opção do compilador: /clr
Exemplos
O exemplo de código a seguir demonstra como uma interface pode definir o comportamento de uma função de relógio.
// 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
O exemplo de código a seguir mostra duas maneiras de implementar funções com a mesma assinatura declarada em várias interfaces e em que locais essas interfaces são usadas por uma 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 {}
};