Interfejsy ogólne (C++/CLI)
Ograniczenia dotyczące parametrów typu w klasach są takie same jak te, które mają zastosowanie do parametrów typu w interfejsach (zobacz Klasy ogólne (C++/CLI)).
Reguły kontrolujące przeciążenie funkcji są takie same w przypadku funkcji w klasach ogólnych lub interfejsach ogólnych.
Jawne implementacje składowych interfejsu współpracują z skonstruowanymi typami interfejsów w taki sam sposób jak w przypadku prostych typów interfejsu (zobacz poniższe przykłady).
Aby uzyskać więcej informacji na temat interfejsów, zobacz klasa interfejsu.
Składnia
[attributes] generic <class-key type-parameter-identifier[, ...]>
[type-parameter-constraints-clauses][accesibility-modifiers] interface class identifier [: base-list] { interface-body} [declarators] ;
Uwagi
Atrybuty
(Opcjonalnie) Dodatkowe informacje deklaratywne. Aby uzyskać więcej informacji na temat atrybutów i klas atrybutów, zobacz Atrybuty.
klucz klasy
class lub typename
type-parameter-identifier(s)
Lista identyfikatorów rozdzielonych przecinkami.
type-parameter-constraints-clauses
Przyjmuje formularz określony w ograniczeniach dotyczących parametrów typu ogólnego (C++/CLI)
modyfikatory ułatwień dostępu
(Opcjonalnie) Modyfikatory ułatwień dostępu (np. publiczne, prywatne).
identifier
Nazwa interfejsu.
lista bazowa
(Opcjonalnie) Lista zawierająca co najmniej jeden jawny interfejs podstawowy rozdzielony przecinkami.
treść interfejsu
Deklaracje składowych interfejsu.
Deklaratorów
(Opcjonalnie) Deklaracje zmiennych na podstawie tego typu.
Przykład: Jak zadeklarować i utworzyć wystąpienie interfejsu ogólnego
W poniższym przykładzie pokazano, jak zadeklarować i utworzyć wystąpienie interfejsu ogólnego. W tym przykładzie interfejs IList<ItemType> ogólny jest zadeklarowany. Następnie jest implementowany przez dwie klasy ogólne i List1<ItemType> List2<ItemType>, z różnymi implementacjami.
// generic_interface.cpp
// compile with: /clr
using namespace System;
// An exception to be thrown by the List when
// attempting to access elements beyond the
// end of the list.
ref class ElementNotFoundException : Exception {};
// A generic List interface
generic <typename ItemType>
public interface class IList {
ItemType MoveFirst();
bool Add(ItemType item);
bool AtEnd();
ItemType Current();
void MoveNext();
};
// A linked list implementation of IList
generic <typename ItemType>
public ref class List1 : public IList<ItemType> {
ref class Node {
ItemType m_item;
public:
ItemType get_Item() { return m_item; };
void set_Item(ItemType value) { m_item = value; };
Node^ next;
Node(ItemType item) {
m_item = item;
next = nullptr;
}
};
Node^ first;
Node^ last;
Node^ current;
public:
List1() {
first = nullptr;
last = first;
current = first;
}
virtual ItemType MoveFirst() {
current = first;
if (first != nullptr)
return first->get_Item();
else
return ItemType();
}
virtual bool Add(ItemType item) {
if (last != nullptr) {
last->next = gcnew Node(item);
last = last->next;
}
else {
first = gcnew Node(item);
last = first;
current = first;
}
return true;
}
virtual bool AtEnd() {
if (current == nullptr )
return true;
else
return false;
}
virtual ItemType Current() {
if (current != nullptr)
return current->get_Item();
else
throw gcnew ElementNotFoundException();
}
virtual void MoveNext() {
if (current != nullptr)
current = current->next;
else
throw gcnew ElementNotFoundException();
}
};
// An array implementation of IList
generic <typename ItemType>
ref class List2 : public IList<ItemType> {
array<ItemType>^ item_array;
int count;
int current;
public:
List2() {
// not yet possible to declare an
// array of a generic type parameter
item_array = gcnew array<ItemType>(256);
count = current = 0;
}
virtual ItemType MoveFirst() {
current = 0;
return item_array[0];
}
virtual bool Add(ItemType item) {
if (count < 256)
item_array[count++] = item;
else
return false;
return true;
}
virtual bool AtEnd() {
if (current >= count)
return true;
else
return false;
}
virtual ItemType Current() {
if (current < count)
return item_array[current];
else
throw gcnew ElementNotFoundException();
}
virtual void MoveNext() {
if (current < count)
++current;
else
throw gcnew ElementNotFoundException();
}
};
// Add elements to the list and display them.
generic <typename ItemType>
void AddStringsAndDisplay(IList<ItemType>^ list, ItemType item1, ItemType item2) {
list->Add(item1);
list->Add(item2);
for (list->MoveFirst(); ! list->AtEnd(); list->MoveNext())
Console::WriteLine(list->Current());
}
int main() {
// Instantiate both types of list.
List1<String^>^ list1 = gcnew List1<String^>();
List2<String^>^ list2 = gcnew List2<String^>();
// Use the linked list implementation of IList.
AddStringsAndDisplay<String^>(list1, "Linked List", "List1");
// Use the array implementation of the IList.
AddStringsAndDisplay<String^>(list2, "Array List", "List2");
}
Linked List
List1
Array List
List2
Przykład: deklarowanie interfejsu ogólnego
W tym przykładzie zadeklarowany jest interfejs ogólny , IMyGenIfacei dwa interfejsy IMySpecializedInt inne niż ogólne oraz ImySpecializedString, które specjalizują się w programie IMyGenIface. Dwa wyspecjalizowane interfejsy są następnie implementowane przez dwie klasy i MyIntClass MyStringClass. W przykładzie pokazano, jak specjalizować interfejsy ogólne, utworzyć wystąpienia interfejsów ogólnych i niegenerycznych oraz wywołać jawnie zaimplementowane elementy członkowskie w interfejsach.
// generic_interface2.cpp
// compile with: /clr
// Specializing and implementing generic interfaces.
using namespace System;
generic <class ItemType>
public interface class IMyGenIface {
void Initialize(ItemType f);
};
public interface class IMySpecializedInt: public IMyGenIface<int> {
void Display();
};
public interface class IMySpecializedString: public IMyGenIface<String^> {
void Display();
};
public ref class MyIntClass: public IMySpecializedInt {
int myField;
public:
virtual void Initialize(int f) {
myField = f;
}
virtual void Display() {
Console::WriteLine("The integer field contains: {0}", myField);
}
};
public ref struct MyStringClass: IMySpecializedString {
String^ myField;
public:
virtual void Initialize(String^ f) {
myField = f;
}
virtual void Display() {
Console::WriteLine("The String field contains: {0}", myField);
}
};
int main() {
// Instantiate the generic interface.
IMyGenIface<int>^ myIntObj = gcnew MyIntClass();
// Instantiate the specialized interface "IMySpecializedInt."
IMySpecializedInt^ mySpIntObj = (IMySpecializedInt^) myIntObj;
// Instantiate the generic interface.
IMyGenIface<String^>^ myStringObj = gcnew MyStringClass();
// Instantiate the specialized interface "IMySpecializedString."
IMySpecializedString^ mySpStringObj =
(IMySpecializedString^) myStringObj;
// Call the explicitly implemented interface members.
myIntObj->Initialize(1234);
mySpIntObj->Display();
myStringObj->Initialize("My string");
mySpStringObj->Display();
}
The integer field contains: 1234
The String field contains: My string