Interfaces génériques (Visual C++)
Les restrictions qui s'appliquent aux paramètres de type sur les classes sont les mêmes que celles qui s'appliquent aux paramètres de type sur les interfaces (consultez Classes génériques (C++/CLI)).
Les règles que la surcharge de fonction de contrôle sont les mêmes pour les fonctions dans les classes génériques ou les interfaces génériques.
Travail explicite des implémentations de membre d'interface avec les types muni d'une interface construits de la même façon qu'avec les types d'interfaces simples (consultez les exemples suivants).
Pour plus d'informations sur les interfaces, consultez classe d'interface (extensions du composant C++).
[attributes] generic <class-key type-parameter-identifier[, ...]>
[type-parameter-constraints-clauses][accesibility-modifiers] interface class identifier [: base-list] { interface-body} [declarators] ;
Notes
attributs (facultatif)
les informations déclaratives supplémentaires.Pour plus d'informations sur les attributs et les classes d'attributs, consultez les attributs.clé de classe
class ou typenametype-parameter-identifier(s)
Liste délimitée par des virgules des identificateurs.type-parameter-constraints-clauses
Prend la forme spécifié dans Contraintes sur les paramètres de type générique (C++/CLI)Accessibility-modificateurs (facultatif)
Modificateurs d'Accessibilité (par exemple.public, private).identificateur
Le nom de l'interface.base-liste (facultatif)
Une liste qui contient une ou plusieurs interfaces de base explicites séparés par des virgules.interface-corps
déclarations des membres d'interface.déclarateurs (facultatif)
Déclarations de variables en fonction de ce type.
Exemple
l'exemple suivant montre comment déclarer et instancier une interface générique.dans l'exemple, l'interface générique IList<ItemType> est déclarée.Il est ensuite implémenté par deux classes génériques, List1<ItemType> et List2<ItemType>, avec des implémentations.
// 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");
}
Cet exemple déclare une interface générique, IMyGenIface, et deux interfaces, IMySpecializedInt et ImySpecializedStringnon génériques, qui son IMyGenIface.Les deux interfaces spécialisées sont ensuite implémentées par deux classes, MyIntClass et MyStringClass.L'exemple montre comment spécialiser les interfaces génériques, le générique d'instancié et les interfaces non génériques, et appelle les membres explicitement implémentées sur les interfaces.
// 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();
}