Delegados genéricos (Visual C++)
Puede utilizar parámetros de tipo genérico con delegados. Para obtener más información en delegados, vea delegate (Extensiones de componentes de C++).
[attributes]
generic < [class | typename] type-parameter-identifiers >
[type-parameter-constraints-clauses]
[accessibility-modifiers] delegate result-type identifier
([formal-parameters]);
Parámetros
attributes (Opcional)
Información declarativa adicional. Para obtener más información sobre los atributos y clases de atributos, vea atributos.tipo-parámetro-identificador(es)
Lista separada por comas de identificadores para los parámetros de tipo.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).tipo de resultado
Tipo del valor devuelto del delegado.Identificador
Nombre del delegado.formal-parameters (Optional)
La lista de parámetros del delegado.
Ejemplo
Los parámetros de tipo de delegado se especifican en el punto donde se crea un objeto delegado. El delegado y el método asociado al deben tener la misma firma. A continuación se muestra un ejemplo de una declaración genérica de delegado.
// generics_generic_delegate1.cpp
// compile with: /clr /c
generic < class ItemType>
delegate ItemType GenDelegate(ItemType p1, ItemType% p2);
El ejemplo siguiente se muestra que
No puede utilizar el mismo objeto de delegado con diferentes tipos construidos. Cree diferentes objetos de delegado para tipos diferentes.
Un delegado genérico puede estar asociado a un método genérico.
Cuando un método genérico se denomina sin especificar argumentos de tipo, el compilador intenta deducir los argumentos de tipo para la llamada.
// generics_generic_delegate2.cpp
// compile with: /clr
generic < class ItemType>
delegate ItemType GenDelegate(ItemType p1, ItemType% p2);
generic < class ItemType>
ref struct MyGenClass {
ItemType MyMethod(ItemType i, ItemType % j) {
return ItemType();
}
};
ref struct MyClass {
generic < class ItemType>
static ItemType MyStaticMethod(ItemType i, ItemType % j) {
return ItemType();
}
};
int main() {
MyGenClass<int> ^ myObj1 = gcnew MyGenClass<int>();
MyGenClass<double> ^ myObj2 = gcnew MyGenClass<double>();
GenDelegate<int>^ myDelegate1 =
gcnew GenDelegate<int>(myObj1, &MyGenClass<int>::MyMethod);
GenDelegate<double>^ myDelegate2 =
gcnew GenDelegate<double>(myObj2, &MyGenClass<double>::MyMethod);
GenDelegate<int>^ myDelegate =
gcnew GenDelegate<int>(&MyClass::MyStaticMethod<int>);
}
El ejemplo siguiente declara un delegado genérico GenDelegate<ItemType>y, a continuación crea instancias asociándolo al método MyMethod que utiliza el parámetro de tipo ItemType. Dos instancias del delegado (entero y doble) se crean y se invocan.
// generics_generic_delegate.cpp
// compile with: /clr
using namespace System;
// declare generic delegate
generic <typename ItemType>
delegate ItemType GenDelegate (ItemType p1, ItemType% p2);
// Declare a generic class:
generic <typename ItemType>
ref class MyGenClass {
public:
ItemType MyMethod(ItemType p1, ItemType% p2) {
p2 = p1;
return p1;
}
};
int main() {
int i = 0, j = 0;
double m = 0.0, n = 0.0;
MyGenClass<int>^ myObj1 = gcnew MyGenClass<int>();
MyGenClass<double>^ myObj2 = gcnew MyGenClass<double>();
// Instantiate a delegate using int.
GenDelegate<int>^ MyDelegate1 =
gcnew GenDelegate<int>(myObj1, &MyGenClass<int>::MyMethod);
// Invoke the integer delegate using MyMethod.
i = MyDelegate1(123, j);
Console::WriteLine(
"Invoking the integer delegate: i = {0}, j = {1}", i, j);
// Instantiate a delegate using double.
GenDelegate<double>^ MyDelegate2 =
gcnew GenDelegate<double>(myObj2, &MyGenClass<double>::MyMethod);
// Invoke the integer delegate using MyMethod.
m = MyDelegate2(0.123, n);
Console::WriteLine(
"Invoking the double delegate: m = {0}, n = {1}", m, n);
}