Antarmuka Generik (C++/CLI)

Pembatasan yang berlaku untuk parameter jenis pada kelas sama dengan yang berlaku untuk parameter jenis pada antarmuka (lihat Kelas Generik (C++/CLI)).

Aturan yang mengontrol kelebihan beban fungsi sama untuk fungsi dalam kelas generik atau antarmuka generik.

Implementasi anggota antarmuka eksplisit bekerja dengan jenis antarmuka yang dibangun dengan cara yang sama seperti dengan jenis antarmuka sederhana (lihat contoh berikut).

Untuk informasi selengkapnya tentang antarmuka, lihat kelas antarmuka.

Sintaks

[attributes] generic <class-key type-parameter-identifier[, ...]>
[type-parameter-constraints-clauses][accesibility-modifiers] interface class identifier [: base-list] {   interface-body} [declarators] ;

Keterangan

Atribut
(Opsional) Informasi deklaratif tambahan. Untuk informasi selengkapnya tentang atribut dan kelas atribut, lihat Atribut.

kunci kelas
class atau typename

type-parameter-identifier
Daftar pengidentifikasi yang dipisahkan koma.

type-parameter-constraints-clauses
Mengambil formulir yang ditentukan dalam Batasan pada Parameter Jenis Generik (C++/CLI)

pengubah aksesibilitas
(Opsional) Pengubah aksesibilitas (misalnya publik, privat).

identifier
Nama antarmuka.

daftar dasar
(Opsional) Daftar yang berisi satu atau beberapa antarmuka dasar eksplisit yang dipisahkan oleh koma.

isi antarmuka
Deklarasi anggota antarmuka.

deklarator
(Opsional) Deklarasi variabel berdasarkan jenis ini.

Contoh: Cara mendeklarasikan dan membuat instans antarmuka generik

Contoh berikut menunjukkan cara mendeklarasikan dan membuat instans antarmuka generik. Dalam contoh, antarmuka IList<ItemType> generik dideklarasikan. Kemudian diimplementasikan oleh dua kelas generik, List1<ItemType> dan List2<ItemType>, dengan implementasi yang berbeda.

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

Contoh: Mendeklarasikan antarmuka generik

Contoh ini mendeklarasikan antarmuka generik, IMyGenIface, dan dua antarmuka non-generik, IMySpecializedInt dan ImySpecializedString, yang mengkhsialisasikan IMyGenIface. Dua antarmuka khusus kemudian diimplementasikan oleh dua kelas, MyIntClass dan MyStringClass. Contoh menunjukkan cara mengkhususkan antarmuka generik, membuat instans antarmuka generik dan non-generik, dan memanggil anggota yang diimplementasikan secara eksplisit pada antarmuka.

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

Lihat juga

Generik