Funzioni generice (C++/CLI)

Una funzione generica è una funzione dichiarata con parametri di tipo. Quando viene eseguita la chiamata, vengono usati i tipi effettivi invece dei parametri di tipo.

Tutte le piattaforme

Osservazioni:

Questa funzionalità non si applica a tutte le piattaforme.

Windows Runtime

Osservazioni:

Questa funzionalità non è supportata in Windows Runtime.

Requisiti

Non applicabile.

Common Language Runtime

Una funzione generica è una funzione dichiarata con parametri di tipo generico. Quando viene eseguita la chiamata, vengono usati i tipi effettivi invece dei parametri di tipo.

Sintassi

generic-declaration:
  generic<generic-parameter-list>constraint-clause-list_optfunction-definition

generic-parameter-list:
  generic-parameter
  generic-parameter-list , generic-parameter

generic-parameter:
  attributes_optclassidentifier
  attributes_opttypenameidentifier

constraint-clause-list:
  constraint-clause-list_optconstraint-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

Parametri

generic-parameter-list
Elenco delimitato da virgole di identificatori di parametri di tipo generico con attributi facoltativamente.

attributes
(Facoltativo) Informazioni dichiarative aggiuntive. Per altre informazioni sugli attributi e sulle classi di attributi, vedere attributi.

constraint-clause-list
Questo elenco facoltativo specifica le restrizioni sui tipi che possono essere usati come argomenti di tipo. Accetta il formato specificato in Vincoli sui parametri di tipo generico (C++/CLI).

function-definition
Definizione di un metodo o di una funzione autonoma. La funzione potrebbe non avere un virtual modificatore, che non è consentito perché i metodi virtuali potrebbero non essere generici. Il corpo della funzione può fare riferimento agli identificatori di parametro di tipo generico. La funzione può essere una operator funzione.

generic-id
Quando si richiama un'istanza di una funzione generica, specificare i tipi usati per implementarlo in generic-argument-list. Questo elenco corrisponde a generic-parameter-liste deve soddisfare i vincoli dell'oggetto facoltativo constraint-clause-list.

generic-name
Una funzione generica può avere un identifier nome o una operator funzione.

Osservazioni:

Le funzioni generiche sono funzioni dichiarate con uno o più parametri di tipo generico. Possono essere metodi in funzioni class autonome o structo . Una dichiarazione generica singola dichiara in modo implicito una famiglia di funzioni che differiscono solo per la sostituzione di un tipo effettivo diverso per il parametro di tipo generico.

Un class costruttore o struct non può essere dichiarato con parametri di tipo generico.

Quando viene chiamato, il parametro di tipo generico viene sostituito da un tipo effettivo. Il tipo effettivo può essere specificato in modo esplicito tra parentesi angolate usando una sintassi simile a una chiamata di modello di funzione. Se la chiamata viene eseguita senza parametri di tipo, il compilatore proverà a dedurre il tipo effettivo dai parametri forniti nella chiamata di funzione. Il compilatore segnala un errore se l'argomento di tipo previsto non può essere dedotto dai parametri usati.

Requisiti

Opzione del compilatore: /clr

Esempi

L'esempio di codice seguente illustra una funzione generica.

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

Le funzioni generiche possono essere sottoposte a overload in base alla firma o all'arità, al numero di parametri di tipo in una funzione. È anche possibile eseguire l'overload di funzioni generiche con funzioni non generiche con lo stesso nome, a condizione che le funzioni differiscano per qualche parametro di tipo. È ad esempio possibile eseguire l'overload delle funzioni seguenti:

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

L'esempio seguente usa una funzione generica per trovare il primo elemento in una matrice. Dichiara MyClass, che eredita dalla classe di base MyBaseClass. MyClass contiene una funzione generica, MyFunction, che chiama un'altra funzione generica, MyBaseClassFunction, all'interno della classe di base. In main la funzione generica, MyFunction, viene chiamata usando argomenti di tipo diversi.

// 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!

Vedi anche

Estensioni componenti per .NET e UWP
Generics