Templates de Funções

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy. Lição 64 de 104.

Imagine escrever uma função para encontrar o maior de dois inteiros e, depois, perceber que você precisa da mesma lógica para números de ponto flutuante e, novamente, para strings. Sem templates, você escreveria funções quase idênticas para cada tipo. Os templates de função resolvem isso, permitindo escrever a lógica uma única vez e fazer com que o compilador gere automaticamente versões específicas para cada tipo.

Um modelo de função usa a palavra-chave template seguida por parâmetros de modelo entre colchetes angulares:

template <typename T>
T maximum(T a, T b) {
    return (a > b) ? a : b;
}

int main() {
    std::cout << maximum(5, 3) << std::endl;       // Usa a versão int
    std::cout << maximum(3.14, 2.71) << std::endl; // Usa a versão double
    std::cout << maximum('a', 'z') << std::endl;   // Usa a versão char
}

O compilador examina cada chamada e gera uma função concreta para aquele tipo específico. Esse processo é chamado de instanciação de template. Você também pode especificar explicitamente o tipo quando necessário:

std::cout << maximum<double>(5, 3.14) << std::endl;  // Força a versão double

Os templates podem ter vários parâmetros de tipo, permitindo designs ainda mais flexíveis:

template <typename T, typename U>
void printPair(T first, U second) {
    std::cout << first << ", " << second << std::endl;
}

printPair(42, "hello");    // T=int, U=const char*
printPair(3.14, 100);      // T=double, U=int

Os templates de função fornecem polimorfismo em tempo de compilação — o tipo é determinado quando o código é compilado, não em tempo de execução. Isso significa nenhuma sobrecarga em tempo de execução em comparação com funções virtuais, tornando os templates ideais para código genérico crítico para o desempenho.

Desafio

Fácil

Vamos criar um kit de ferramentas utilitárias usando templates de função para criar operações reutilizáveis que funcionem com qualquer tipo compatível. Você organizará suas funções genéricas em um arquivo de cabeçalho e demonstrará sua flexibilidade no programa principal.

Você criará dois arquivos:

MathUtils.h: defina uma coleção de templates de função que realizam operações comuns:
minimum: uma função template que recebe dois valores do mesmo tipo e retorna o menor deles.
clamp: uma função template que recebe três parâmetros: um valor, um limite inferior e um limite superior. Ela retorna o valor restrito aos limites (retorna o limite inferior se o valor for menor que o limite inferior, o limite superior se o valor for maior que o limite superior; caso contrário, retorna o próprio valor).
swapValues: uma função template que recebe duas referências do mesmo tipo e troca seus valores.
main.cpp: leia seis entradas (cada uma em uma linha separada):
1. Primeiro inteiro
2. Segundo inteiro
3. Um valor double para limitar
4. Limite inferior (double)
5. Limite superior (double)
6. Um caractere
Demonstre seus templates:
1. Encontrando o menor dos dois inteiros e imprimindo: Min of <a> and <b>: <result>
2. Encontrando o menor entre o caractere 'm' e o caractere informado, imprimindo: Min of m and <char>: <result>
3. Limitando o valor double e imprimindo: Clamp <value> to [<low>, <high>]: <result>
4. Limitando o primeiro inteiro ao intervalo [0, 100] e imprimindo: Clamp <value> to [0, 100]: <result>
5. Trocando os dois inteiros e imprimindo: After swapValues: <a>, <b>

Por exemplo, com as entradas 25, 10, 3.7, 1.0, 5.0 e z:

Min of 25 and 10: 10
Min of m and z: m
Clamp 3.7 to [1, 5]: 3.7
Clamp 25 to [0, 100]: 25
After swapValues: 10, 25

Observe como cada função template funciona perfeitamente com inteiros, doubles e caracteres: o compilador gera a versão apropriada para cada tipo usado. Sua função swapValues deve modificar as variáveis originais por meio de referências, demonstrando que os templates funcionam com parâmetros de referência assim como as funções comuns.

Experimente você mesmo

#include <iostream>
#include "MathUtils.h"
using namespace std;

int main() {
    // Ler entradas
    int a, b;
    double value, low, high;
    char ch;
    
    cin >> a;
    cin >> b;
    cin >> value;
    cin >> low;
    cin >> high;
    cin >> ch;
    
    // TODO: Use o template minimum para encontrar o min de dois inteiros
    // Imprima: "Min of <a> and <b>: <result>"
    
    // TODO: Use o template minimum para encontrar o min de 'm' e o caractere de entrada
    // Imprima: "Min of m and <char>: <result>"
    
    // TODO: Use o template clamp no valor double
    // Imprima: "Clamp <value> to [<low>, <high>]: <result>"
    
    // TODO: Use o template clamp no primeiro inteiro com o intervalo [0, 100]
    // Imprima: "Clamp <value> to [0, 100]: <result>"
    
    // TODO: Use o template swapValues nos dois inteiros
    // Print: "After swapValues: <a>, <b>"
    
    return 0;
}