Programar em C++/Templates

Esta página precisa ser reciclada (discuta). Ao melhorá-la, você estará ajudando o Wikilivros.

Os templates permitem a criação de código reusado, usando templates é possível criar funções e classes genéricas. Assim o tipo de dados usados pelas funções são parâmetros. Podemos criar um template para soma, e depois enviamos que tipo de dados queremos somar, podemos até utilizar a sobrecarga de operadores para tal fim.

Funções genéricas

 template <class Ttype> ret-type func-name(parameter list)
 {
 // body of function
 }

vamos dar o exemplo

 // Function template example.
 #include <iostream>
 using namespace std;
 template <class X> void swapargs(X &a, X &b)// This is a function template.
    {
        X temp;
        temp = a;
        a = b;
        b = temp;
    }
 int main()
 {
    int i=10, j=20;
    double x=10.1, y=23.3;
    char a='x', b='z';
    cout << "Original i, j: " << i << ' ' << j << '\n';
    cout << "Original x, y: " << x << ' ' << y << '\n';
    cout << "Original a, b: " << a << ' ' << b << '\n';
    swapargs(i, j); // swap integers
    swapargs(x, y); // swap floats
    swapargs(a, b); // swap chars
    cout << "Swapped i, j: " << i << ' ' << j << '\n';
    cout << "Swapped x, y: " << x << ' ' << y << '\n';
    cout << "Swapped a, b: " << a << ' ' << b << '\n';
    system ("pause");
    return 0;
 }

Aqui criamos uma template para uma função que troca os valores, e essa função pode ser usada quer tendo ints, doubles ou chars. nós utilizamos o X como data type. neste caso temos swapargs() como uma função genérica. O compilador automaticamente cria 3 versões para a função swapargs(). portanto os templates não são bem funções que funcionam para as vários tipos, mas antes os templates permitem poupar escrita ao programador para não ter de especificar cada tipo.

template function ou generic function (é uma definição de uma função precedida pela statement template

especialização == é quando o compilador cria a versão especifica da função. também é chamada de generated function. o ato de gerar a função é referido como instantiating.

há quem prefira ter a declaração do template da seguinte forma

 template <class X> 
 void swapargs(X &a, X &b)// This is a function template.
    {
        X temp;
        temp = a;
        a = b;
        b = temp;
    }

O que se torna bem parecido com o modelo utilizado anteriormente.

Uma função com dois tipos genéricos:

 #include <iostream>
 using namespace std;
 template <class type1, class type2>
    void myfunc(type1 x, type2 y)
            {
            cout << x << ' ' << y << '\n';
            }
 int main()
 {
    myfunc(10, "hi");
    myfunc(0.23, 10L);
    system ("pause");
    return 0;
 }

Repare que temos dois tipos de dados diferentes na mesma função.

Sobrecarregando explicitamente uma função genérica

apesar de uma função genérica poder ser overload automaticamente se necessário, nós podemos explicitar. a isso chamamos deexplicit specialization