Templates em C++ nos permitem criar classes, métodos e outros recursos de forma que possam receber tipos de dados passados como argumentos em tempo de codificação.

Sintaxe

template<typename T>

Onde

template: palavra reservada para declara um template.
typename: tipo de dado que será passado como argumento
T: identificador de tipo genérico. Podendo ser qualquer outra letra.

Com o uso de template, podemos agora definir uma assinatura de função ou método que recebe tipos de dados como argumento:

Sintaxe

template<typename T> T nome_funcao(T parametro1, T parametro2, ...)
{
    //corpo 
}

O exemplo abaixo demonstra uma função, que utiliza generic, para somar dois valores, inteiros e floats, que são recebidos como parâmetros.

Exemplo 1

#include <iostream>
using namespace std;

//função
template <typename T> T funcao(T p1, T p2)
{
    return p1 + p2;
}

int main()
{
    cout << funcao(1,2) << endl; //soma de inteiros
    cout << funcao(1.1,2.1) << endl; //soma de ponto-flutuante

    return 0;
}

Saída

3
3.2

O operador (+) que aceita a operação de soma entre dois valores, tanto inteiros quanto ponto-flutuante. Porém, nem todos os tipos de dados aceitam esse operador. Nesses casos a sobrecarga de operadores deve ser feita para esse tipo de dado.

Quando uma classe precisa manipular dados de forma independente do tipo, podemos também utilizar o template para transformar uma classe em genérica como pode ser visto abaixo:

Sintaxe

template<typename T> class nome_classe
{
    modificador_acesso: 
        T atributo;
        nome_classe(T par); //construtor
        T metodo(T par); //método
}

Onde

template: palavra reservada para declara uma template.
typename: tipo de dado que será passado como argumentos.
T: nome do argumento. Podendo ser qualquer outra letra.

A implementação dos métodos da classe template é feita utilizando o operador (::) seguindo a sintaxe abaixo:

Sintaxe: construtor

template<typename T> nome_classe<T>::nome_classe(T arg1, T arg2, ...)

Sintaxe: método

template<typename T> nome_classe<T>::nome_metodo(T arg1, T arg2, ...)

Exemplo 2

#include <iostream>
using namespace std;

template <typename T> class MinhaClasse 
{
  public:
    T prop1;
    T prop2;
    
    MinhaClasse(T p1, T p2); //construtor "genérico"
    T metodo1( T a1, T a2);  //método "genérico"
};
//construtor
template <typename T> MinhaClasse<T>::MinhaClasse(T a1, T a2)
{
    prop1 = a1;
    prop2 = a2;
}
//método
template <typename T> T MinhaClasse<T>::metodo1( T a1, T a2)
{
    cout << "prop1:" << prop1 << " prop2:" << prop2 << endl;
    cout << "a1:" << a1 << " a2:" << a2 << endl;
    
    return a1*prop1 + a2*prop2;
}
int main()
{
    MinhaClasse <int> _classe(2,2);
    cout << _classe.metodo1(3,3) << endl;
    cout << _classe.metodo1(1.5,1.5);
    return 0;
}

Saída

prop1:2 prop2:2
a1:3 a2:3
12
prop1:2 prop2:2
a1:1 a2:1
4

Para utilizarmos templates com mais de um tipo de dado genérico, além do T já visto, utilizamos (,) como separador de argumentos. Esses devem ter diferentes letras para suas representações.

Sintaxe

template <typename T1, T2, TN>

Onde

T1..TN: letras diferentes para argumento

Exemplo 3

#include <iostream>
using namespace std;

//classe
template <typename T1, typename T2> class MinhaClasse 
{
  private:
    T1 prop1;
    T2 prop2;
    
  public:
    MinhaClasse(T1 p1, T2 p2);
    void metodo1();
};
//construtor
template <typename T1, typename T2> MinhaClasse<T1,T2>::MinhaClasse(T1 a1, T2 a2)
{
    prop1 = a1;
    prop2 = a2;
}
//método
template <typename T1, typename T2> void MinhaClasse<T1,T2>::metodo1( )
{
    cout << "prop1:" << prop1 << endl << "prop2:" << prop2 << endl;
}
int main()
{
    MinhaClasse <int,float> _classe(2,2.5);
    _classe.metodo1();

    return 0;
}

Saída

prop1:2
prop2:2.5