Funções genéricas (C++/CLI)

Uma função genérica é uma função declarada com parâmetros de tipo. Quando chamados, os tipos reais são usados, ao invés dos parâmetros de tipo.

Todas as plataformas

Comentários

Esse recurso não se aplica a todas as plataformas.

Windows Runtime

Comentários

Este recurso não é compatível com o Windows Runtime.

Requisitos

Não aplicável.

Common Language Runtime

Uma função genérica é uma função declarada com parâmetros de tipo genérico. Quando chamados, os tipos reais são usados, ao invés dos parâmetros de tipo.

Sintaxe

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
Uma lista separada por vírgulas de identificadores de parâmetro de tipo genérico opcionalmente atribuídos.

attributes
(Opcional) Informações declarativas adicionais. Saiba mais sobre atributos e classes de atributos em Atributos.

constraint-clause-list
Esta lista opcional especifica restrições quanto aos tipos que podem ser usados como argumentos de tipo. Ela assume o formato especificado em Restrições em parâmetros de tipo genérico (C++/CLI).

function-definition
Uma definição de um método ou função autônoma. A função pode não ter um modificador virtual, o que não é permitido, pois os métodos virtuais não podem ser genéricos. O corpo da função pode se referir a identificadores de parâmetro de tipo genérico. A função pode ser uma função operator.

generic-id
Quando você invoca uma instância de uma função genérica, especifica os tipos usados para implementá-la na generic-argument-list. Essa lista corresponde ao generic-parameter-list e precisa atender às restrições da constraint-clause-list opcional.

generic-name
Uma função genérica pode ter um identifier como nome, ou pode ser uma função operator.

Comentários

Funções genéricas são funções declaradas com um ou mais parâmetros de tipo genérico. Elas podem ser métodos em uma class ou struct, ou em funções autônomas. Uma única declaração genérica declara implicitamente uma família de funções que diferem apenas na substituição de um tipo real diferente para o parâmetro de tipo genérico.

Um construtor de class ou struct não pode ser declarado com parâmetros de tipo genérico.

Quando chamado, o parâmetro de tipo genérico é substituído por um tipo real. O tipo real pode ser especificado explicitamente entre colchetes angulares usando uma sintaxe semelhante a uma chamada de modelo de função. Se for chamado sem os parâmetros de tipo, o compilador tentará deduzir o tipo real a partir dos parâmetros fornecidos na chamada de função. O compilador relatará um erro se o argumento de tipo pretendido não puder ser deduzido dos parâmetros usados.

Requisitos

Opção do compilador: /clr

Exemplos

O seguinte código de exemplo demonstra uma função 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);
}

Funções genéricas podem ser sobrecarregadas com base na assinatura ou aridade, o número de parâmetros de tipo em uma função. Além disso, funções genéricas podem ser sobrecarregadas com funções não genéricas de mesmo nome, desde que as funções sejam diferentes em alguns parâmetros de tipo. Por exemplo, as seguintes funções podem ser sobrecarregadas:

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

O exemplo a seguir usa uma função genérica para localizar o primeiro elemento em uma matriz. Ele declara MyClass, que herda da classe base MyBaseClass. MyClass contém uma função genérica, MyFunction, que chama outra função genérica, MyBaseClassFunction, dentro da classe base. Em main, a função genérica, MyFunction, é chamada usando 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!

Confira também

Extensões de componentes para .NET e UWP
Genéricos