Funciones genéricas (C++/CLI)

Una función genérica es una función que se declara con parámetros de tipo. Cuando se invoca, se usan tipos reales en lugar de los parámetros de tipo.

Todas las plataformas

Comentarios

Esta característica no se aplica a todas las plataformas.

Windows en tiempo de ejecución

Comentarios

Esta característica no se admite en Windows Runtime.

Requisitos

No aplicable.

Common Language Runtime

Una función genérica es una función que se declara con parámetros de tipo genéricos. Cuando se invoca, se usan tipos reales en lugar de los parámetros de tipo.

Sintaxis

generic-declaration:
  generic < generic-parameter-list >optconstraint-clause-list function-definition

generic-parameter-list:
  generic-parameter
  generic-parameter-list , generic-parameter

generic-parameter:
  attributes_opt class identifier
  attributes_opt typename identifier

constraint-clause-list:
  constraint-clause-list_opt constraint-clause

constraint-clause:
  where identifier : constraint-item-list

constraint-item-list:
  constraint-item
  constraint-item-list , constraint-item

constraint-item:
  type-id
  ref class
  ref struct
  value class
  value struct
  gcnew ( )

generic-id:
  generic-name < generic-argument-list >

generic-name:
  identifier
  operator-function-id

generic-argument-list:
  generic-argument
  generic-argument-list , generic-argument

generic-argument:
  type-id

Parámetros

generic-parameter-list
Lista separada por comas de identificadores de parámetros de tipo genérico con atributos opcionales.

attributes
(Opcional) Información declarativa adicional. Para más información sobre atributos y clases de atributos, consulte Atributos.

constraint-clause-list
Esta lista opcional especifica las restricciones de los tipos que pueden usarse como argumentos de tipo. Toma la forma especificada en el artículo Restricciones en parámetros de tipo genérico (C++/CLI).

function-definition
Definición de un método o una función independiente. Es posible que la función no tenga un modificador virtual, que no se permite, ya que los métodos virtuales pueden no ser genéricos. El cuerpo de la función, que puede hacer referencia a los identificadores de parámetro de tipo genérico. La función puede ser una función operator.

generic-id
Cuando se invoca una instancia de una función genérica, se especifican los tipos usados para implementarlo en generic-argument-list. Esta lista corresponde a generic-parameter-list y debe cumplir las restricciones del constraint-clause-list opcional.

generic-name
Una función genérica puede tener identifier como nombre o puede ser una función operator.

Comentarios

Las funciones genéricas son funciones declaradas con uno o más parámetros de tipo genérico. Pueden ser métodos de class o struct, o funciones independientes. Una sola declaración genérica declara implícitamente una familia de funciones que solo difieren en la sustitución de un tipo real diferente por el parámetro de tipo genérico.

Un constructor de class o struct no se puede declarar con parámetros de tipo genérico.

Cuando se invoca, el parámetro de tipo genérico se reemplaza por un tipo real. El tipo real se puede especificar explícitamente entre corchetes angulares mediante la sintaxis similar a una llamada de plantilla de función. Si se invoca sin los parámetros de tipo, el compilador intentará deducir el tipo real de los parámetros proporcionados en la llamada de función. Si el argumento de tipo deseado no se puede deducir de los parámetros usados, el compilador notificará un error.

Requisitos

Opción del compilador: /clr

Ejemplos

En ejemplo de código siguiente se muestra una función genérica.

// generics_generic_function_1.cpp
// compile with: /clr
generic <typename ItemType>
void G(int i) {}

ref struct A {
   generic <typename ItemType>
   void G(ItemType) {}

   generic <typename ItemType>
   static void H(int i) {}
};

int main() {
   A myObject;

   // generic function call
   myObject.G<int>(10);

   // generic function call with type parameters deduced
   myObject.G(10);

   // static generic function call
   A::H<int>(10);

   // global generic function call
   G<int>(10);
}

Las funciones genéricas se pueden sobrecargar según su signatura o aridad, el número de parámetros de tipo en una función. Además, las funciones genéricas se pueden sobrecargar con funciones no genéricas del mismo nombre, siempre y cuando las funciones se diferencien en algunos parámetros de tipo. Por ejemplo, se pueden sobrecargar las siguientes funciones:

// generics_generic_function_2.cpp
// compile with: /clr /c
ref struct MyClass {
   void MyMythod(int i) {}

   generic <class T>
   void MyMythod(int i) {}

   generic <class T, class V>
   void MyMythod(int i) {}
};

En el ejemplo siguiente se usa una función genérica para hallar el primer elemento de una matriz. Declara MyClass, que hereda de la clase base MyBaseClass. MyClass contiene una función genérica, MyFunction, que llama a otra función genérica, MyBaseClassFunction, dentro de la clase base. En main, la función genérica, MyFunction, se invoca con argumentos de tipo diferentes.

// generics_generic_function_3.cpp
// compile with: /clr
using namespace System;

ref class MyBaseClass {
protected:
   generic <class ItemType>
   ItemType MyBaseClassFunction(ItemType item) {
      return item;
   }
};

ref class MyClass: public MyBaseClass {
public:
   generic <class ItemType>
   ItemType MyFunction(ItemType item) {
      return MyBaseClass::MyBaseClassFunction<ItemType>(item);
   }
};

int main() {
   MyClass^ myObj = gcnew MyClass();

   // Call MyFunction using an int.
   Console::WriteLine("My function returned an int: {0}",
                           myObj->MyFunction<int>(2003));

   // Call MyFunction using a string.
   Console::WriteLine("My function returned a string: {0}",
   myObj->MyFunction<String^>("Hello generic functions!"));
}

My function returned an int: 2003
My function returned a string: Hello generic functions!

Consulte también

Extensiones de componentes de .NET y UWP
Genéricos