Panoramica dei modelli

I modelli, che sono talvolta denominati tipi con parametri, sono meccanismi per le funzioni generarici e le classi base a parametri di tipo.Utilizzando i modelli, è possibile progettare una singola classe o funzionare che agiscono sui dati di molti tipi, anziché creare una classe separata per ogni tipo.

Note

Ad esempio, per creare una funzione indipendente dai tipi che restituisce il valore minimo di due parametri senza utilizzare i modelli, sarebbe necessario scrivere un insieme di funzioni in overload nel modo seguente:

// what_are_templates1.cpp
// compile with: /c
// min for ints
int min( int a, int b ) {
   return ( a < b ) ? a : b;
}

// min for longs
long min( long a, long b ) {
   return ( a < b ) ? a : b;
}

// min for chars
char min( char a, char b ) {
   return ( a < b ) ? a : b;
}

Utilizzando i modelli, è possibile ridurre questa duplicazione a un singolo modello di funzione:

// what_are_templates2.cpp
// compile with: /c
template <class T> T min( T a, T b ) {
   return ( a < b ) ? a : b;
}

I modelli possono ridurre notevolmente la dimensione del codice sorgente e aumentare la flessibilità di codice senza ridurre l'indipendenza dai tipi.

Esistono due tipi principali di modelli: modelli di funzione e modelli della classe.Nell'esempio precedente, min si tratta di un template di funzione.Il modello di classe è una classe con un parametro, ad esempio:

// what_are_templates3.cpp
template <class T> class A {
   T m_t;
   public:
      A(T t): m_t(t) {} 
      void f(T t);
};

int main() {
   A<int> a(10);
}

I modelli vengono dichiarati anziché e definiti come altre funzioni e classi, con alcune differenze fondamentali.Una dichiarazione del template non definisce una funzione o classe; definisce solo una struttura sintattica per una classe o la funzione.Una vera e propria classe o funzione viene creata da un modello da una creazione di istanze chiamata del processo.Le classi o le funzioni utente create sono definiti creare un'istanza.Ad esempio, un modello di classe:

template <class T> struct A { . . . };

può essere utilizzato per creare istanze delle classi per A<int>, A<char>, A<int*>, A<MyClass*>, e così via.

La creazione di istanze delle classi o funzioni può essere eseguita in modo esplicito o implicito.La creazione di istanza esplicita consente di chiamare il codice che versioni del modello devono essere generate.La creazione di istanze implicita consente i modelli da creare un'istanza di in base alle necessità nel punto in cui innanzitutto vengono utilizzate.

I modelli possono essere anche con parametri da un parametro di valore, nel qual caso il parametro di template è dichiarato come parametro a una funzione.I tipi a virgola mobile e i tipi di classe non sono consentiti come parametri di valore.

// what_are_templates4.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

template <int i> class A {
   int array[i];
public:
   A() { memset(array, 0, i*sizeof(int)); }
};

int main() {
   A<10> a;
}

Un problema comune con i modelli è che possono essere una soluzione unitaglia, pertanto lo stesso codice viene applicato a tutti i tipi.Se è necessario personalizzare il comportamento del modello per un tipo particolare, è possibile utilizzare la specializzazione.Utilizzando specializzazione esplicita, un modello può essere specializzato per un tipo reale particolare, non un tipo generico.Il modello di classe può anche parzialmente essere specializzato, che è utile se si dispone di un modello con parametri di tipo e maggiore sarà sufficiente da personalizzare il comportamento rispetto solo ad alcuni tutti i parametri.Una specializzazione parziale è ancora generica e necessita di argomenti di modello e di produrre una vera e propria classe istanziata.

Vedere anche

Altre risorse

Modelli