Interfaces genéricas (Visual C++)

Artículo
02/19/2013

Las restricciones que se aplican a los parámetros de tipo en clases son iguales que las que se aplican a los parámetros de tipo en interfaces (vea Clases genéricas (C++/CLI)).

Las reglas que la sobrecarga de la función de control es el mismo para las funciones de clases o de interfaces genéricas genéricas.

Las implementaciones explícitas de miembro de interfaz funcionan con tipos de interfaz construidos de la misma manera que con los tipos de interfaz simples (vea los ejemplos siguientes).

Para obtener más información sobre interfaces, vea interface class (Extensiones de componentes de C++).

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

Comentarios

atributos (opcional)
información declarativa adicional.Para obtener más información sobre los atributos y clases de atributos, vea atributos.
clase-clave
class o typename
type-parameter-identifier(s)
Lista separada por comas de identificadores.
type-parameter-constraints-clauses
Tiene el formato especificado en Restricciones de parámetros de tipo genérico (C++/CLI)
accesibilidad-modificadores (opcional)
Modificadores de accesibilidad (por ejemplo.public, private).
Identificador
el nombre de la interfaz.
base-lista (opcional)
Una lista que contiene una o más interfaces base explícitas separados por comas.
interfaz-cuerpo
declaraciones de los miembros de la interfaz.
declarantes (opcional)
Declaraciones de variables basadas en este tipo.

Ejemplo

El ejemplo siguiente se muestra cómo declarar y crear instancias de una interfaz genérica.en el ejemplo, se declara la interfaz genérica IList<ItemType> .A continuación se implementa mediante dos clases genéricas, List1<ItemType> y List2<ItemType>, con distintas implementaciones.

// 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");
}

Este ejemplo declara una interfaz genérica, IMyGenIface, y dos interfaces, IMySpecializedInt y ImySpecializedStringno genéricos, que especializados IMyGenIface.Las dos interfaces especializadas se implementan las dos clases, MyIntClass y MyStringClass.El ejemplo muestra cómo especializar interfaces genéricas, crear instancias de interfaces genéricas y no genéricas, y llamar a los miembros explícitamente implementados en las 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();
}

Vea también

Otros recursos

Genéricos (Extensiones de componentes de C++)

Compartir a través de

Interfaces genéricas (Visual C++)

Comentarios

Ejemplo

Vea también

Otros recursos

Recursos adicionales