Arnaut - Oficina de Programação

Help Desk

Templates

Usando template, é possível criar funções genéricas e classes genéricas. Em uma função ou classe genérica o tipo de dados sobre o qual a função vai operar é também definido como um parâmetro. Assim, você pode usar a mesma função ou a mesma classe com vários tipos de dados, sem a necessidade de re-codificar a função ou a classe para cada tipo de dado em particular.

Uma função genérica define um conjunto de operações que pode ser aplicado a vários tipos de dados. Esse mecanismo é que permite criar funções únicas a serem utilizadas para uma ampla variedade de tipos de dados.

Você já deve ter notado que muitos algoritmos são iguais não importando o tipo de dado a que serão aplicados em tempo de execução.

Por exemplo, o algoritmo quicksort é o mesmo, independentemente de estar sendo aplicado a uma matriz de números inteiros ou a uma matriz de números ponto flutuante. Ou seja, o tipo de dado a ser ordenado pode variar mas o conjunto de instruções que realiza a ordenação é sempre o mesmo.

Criando funções genéricas pode-se definir, não importando o tipo de dado, a natureza do algoritmo. Sabendo tratar-se de uma função genérica, o compilador automaticamente gera o código correto para o tipo de dado quando encontra uma chamada para a função dentro do código fonte do programa.

Uma função genérica é criada com o uso da palavra chave template que permite definir o que a função vai realizar, deixando ao compilador a tarefa de gerar o código adicional necessário para compatibilizar as operações da função com os tipos de dados fornecidos em cada caso.

A forma geral de uma função template é a seguinte:

template <class Ttype> ret-type func-name (parameter list)
{
   // Corpo da função
}

Onde Ttype é uma denominação geral, variável, do tipo de dado usado pela função. Essa denominação pode ser utilizada no código fonte da implementação da função, mas é sempre uma denominação geral que será substituída automaticamente pelo compilador pelo tipo de dado efetivamente fornecido quando de cada chamada da função.

A seguir um pequeno exemplo de uma função que troca os conteúdos de duas variáveis entre si. Já que o objetivo dessa função é trocar o conteúdo de duas variáveis de qualquer tipo, é um caso em que se aplica a criação de uma função genérica, ou em outros termos, de uma função template.

#include <iostream.h>
template <class X> void Swap (X &a, X &b)
{
   X temp = a;
   a = b;
   b = temp;
}

int main ()
{
   int i = 10;
   int j = 20;
   float x = 10;
   float y = 23.3;
   char a = 'x';
   char b = 'z';

   Swap (i, j); // Troca inteiros
   Swap (x, y); // Troca ponto flutuante
   Swap (a, b); // Troca caracteres

   return(0);
}

Olhando mais de perto, a linha

template <class X> void Swap (X &a, X &b)

informa ao compilador que uma função template está sendo criada e que sua definição genérica se inicia aqui. X é um tipo de dado genérico, usado aqui como uma variável. Após o código referente à template está a declaração da função Swap

void Swap (X &a, X &b)

A função é declarada usando X como tipo de dado das variáveis cujos conteúdos serão trocados.

Em main, a função Swap é chamada três vezes, em cada chamada com um tipo de de dado diferente: int, float e char. Devido ao fato de Swap ser uma função genérica - declarada com a palavra chave template - o compilador se encarrega de criar três versões para a função Swap, uma para cada um dos tipos de dados fornecidos nas chamadas da função.

Pode-se declarar funções template com mais de um tipo genérico de dado:

#include <iostream.h>
template <class T1, class T2> void MyFunc (T1 &a, T2 &b)
{
   cout << a << b << endl;
}
int main ()
{
   MyFunc (10, "Oi");
   MyFunc (0.23, 10L);

   return(0);
}

Nesse exemplo, os tipos genéricos T1 e T2 serão substituídos pelo compilador com os tipos de dados int, char, double e long respectivamente, quando o compilador gerar cada uma das instâncias da função MyFunc dentro de main.

Em síntese: quando você usa funções genéricas - funções template - você está pedindo ao compilador que gere automaticamente diferentes versões da mesma função conforme sejam os tipos de dados fornecidos nas chamadas à função.