Template

Lo scopo dei template è quello di permettere di scrivere il codice una sola volta e di utilizzarlo molte volte, in quei casi in cui si vuole lavorare con tipi in qualche modo parametrizzati. Per esempio, supponiamo che tu abbia bisogno di array di int, float o oggetti. Basta che tu scriva una classe Array ed usi in essa un tipo non-determinato. La sintassi è un po' complessa, ma i risultati hanno molto effetto: 
// Dichiara la classe
template <int N, class A>
class Array
{
  A *array;
public:  
  Array();
  ~Array();
  A& operator[] (int i);
};

// Dichiara il costruttore
template <int N, class A>
Array <N, A>::Array()
{
  array = new A[N];
}

// Dichiara il distruttore
template <int N, class A>
Array <N, A>::~Array()
{
  delete [] array;
}

// Dichiara la funzione membro
template <int N, class A>
A &Array <N, A>::operator[] (int i)
{
  return array[i];
}

class ExampleClass
{
public:
  int a;
};

int main (int, char **)
{
  Array <5, float> real_vector;
  Array <200, char> string;
  Array <10, ExampleClass> object_vector;

  int i;
  for (i = 0; i < 5; i++) real_vector[i] = 1.0;
  for (i = 0; i < 200; i++) string[i] = 'A';
  for (i = 0; i < 10; i++) object_vector[i].a = 0;

  return 0;
}
Ogni volta che dichiari un oggetto da una classe template, tutto il codice scritto (comprese le funzioni membro) deve esserci compilato nello stesso file prima della della dichiarazione dell'oggetto. Inoltre i template sono spesso usati per piccole funzioni generiche, quindi sono spesso dichiarati come funzioni inline: 
template <int N, class A>
class Array
{
  A *array;
public:
  Array() { array = new A[N]; }
  ~Array() { delete [] array; }
  A& operator[] (int i) { return array[i]; }
};
questa è una definizione oltre che più semplice, più efficiente della stessa classe Array vista prima.

C++