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

Uma função genérica é uma função que é declarada com parâmetros de tipo.Quando chamado, tipos reais são usados em vez dos parâmetros de tipo.

Todas as plataformas

Comentários

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

Tempo de Execução do Windows

Comentários

Este recurso não é suportado no Tempo de Execução do Windows.

Requisitos

Opção de compilador:/ZW

Common Language Runtime

Uma função genérica é uma função que é declarada com parâmetros de tipo.Quando chamado, tipos reais são usados em vez dos parâmetros de tipo.

Sintaxe

[attributes] [modifiers]
return-type identifier <type-parameter identifier(s)>
[type-parameter-constraints clauses]

([formal-parameters])
{
   function-body
}

Parâmetros

• atributos (opcional)
  Informações declarativas adicionais.Para obter mais informações sobre atributos e classes de atributo, consulte atributos.

• modificadores de (opcional)
  Um modificador de função, como, por exemplo, stático. virtualnão é permitido como métodos virtuais não podem ser genéricos.

• tipo de retorno
  O tipo retornado pelo método.Se o tipo de retorno void, nenhum valor de retorno é necessário.

• identificador
  O nome da função.

• identificadores de tipo de parâmetro
  Lista de identificadores separados por vírgulas.

• parâmetros formais (opcional)
  Lista de parâmetros.

• tipo de parâmetro-restrições de cláusulas
  Isso especifica restrições sobre os tipos que podem ser usados como argumentos de tipo e assume a forma especificada em Restrições no genérico Digite parâmetros (C + + / CLI).

• corpo da função
  O corpo do método, consulte identificadores de parâmetro de tipo.

Comentários

Genéricos são funções declaradas com um parâmetro de tipo genérico.Eles podem ser métodos de funções de uma classe ou struct ou autônomo.Uma única declaração genérica declara implicitamente uma família de funções que diferem apenas em substituição de um tipo diferente de real para o parâmetro de tipo genérico.

Em Visual C++, construtores de classe ou struct não podem ser declarados 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 em colchetes angulares usando sintaxe semelhante a uma chamada de função do modelo.Se chamado sem parâmetros de tipo, o compilador tentará deduzir o tipo real de parâmetros fornecidos na chamada de função.Se o argumento Tipo pretendido não pode ser deduzido dos parâmetros usados, o compilador relatará um erro.

Requisitos

Opção de compilador:/clr

Exemplos

Exemplo

O exemplo de código a seguir 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);
}

Exemplo

Funções genéricas podem ser sobrecarregadas com base em assinatura ou aridade, o número de parâmetros em uma função.Além disso, funções genéricas podem ser sobrecarregadas com funções não-genéricas de mesmo nome, como as funções diferem 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) {}
};

Exemplo

O exemplo a seguir usa uma função genérica para encontrar o primeiro elemento em uma matriz.Ele declara MyClass, que herda da classe base MyBaseClass.MyClasscontém uma função genérica, MyFunction, que chama outra função genérica, MyBaseClassFunction, dentro da classe base.Em principal, a função genérica, MyFunction, é chamado com argumentos de tipo diferente.

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

Saída

Consulte também

Conceitos

Extensões de componente para plataformas de tempo de execução

Outros recursos

Genéricos (Extensões de Componentes C++)