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.type-parameter-identifier(s)
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-parámetros (Opcional)
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 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);
}