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:
attributesopt class identifier
attributesopt typename identifier
constraint-clause-list:
constraint-clause-listopt 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!