Especialização de Templates

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy — lição 66 de 104.

Às vezes, um template genérico não funciona bem para todos os tipos. Por exemplo, comparar strings no estilo C com > compara endereços de ponteiros, não o texto real. A especialização de template permite que você forneça uma implementação personalizada para tipos específicos, mantendo a versão genérica para todo o resto.

Uma especialização completa substitui o template inteiro para um tipo específico. Você a declara com uma lista de parâmetros de template vazia e especifica o tipo concreto:

// Template primário
template <typename T>
class Printer {
public:
    void print(T value) {
        std::cout << value << std::endl;
    }
};

// Especialização total para const char*
template <>
class Printer<const char*> {
public:
    void print(const char* value) {
        std::cout << "String: " << value << std::endl;
    }
};

Printer<int> intPrinter;
intPrinter.print(42);           // Saída: 42

Printer<const char*> strPrinter;
strPrinter.print("hello");      // Saída: String: hello

Templates de função também podem ser especializados:

template <typename T>
bool isEqual(T a, T b) {
    return a == b;
}

template <>
bool isEqual<const char*>(const char* a, const char* b) {
    return std::strcmp(a, b) == 0;
}

isEqual(5, 5);              // Usa a versão genérica
isEqual("hi", "hi");        // Usa a versão especializada

O compilador sempre prefere a correspondência mais específica - se existir uma especialização para o tipo exato que está sendo usado, ela será escolhida em vez do template genérico.

Desafio

Fácil

Vamos construir um sistema de formatador ciente de tipos que demonstra como a especialização de templates permite personalizar o comportamento para tipos específicos, mantendo um fallback genérico para todo o resto.

Você criará dois arquivos para organizar seu código de template:

Formatter.h: Defina um template de classe chamado Formatter que formata valores para exibição. Seu template genérico deve funcionar com qualquer tipo, mas você também criará versões especializadas para tipos que precisam de tratamento personalizado.
O template primário Formatter deve ter:
- Um método format() que recebe um valor do tipo T e imprime: Value: <value>
Crie uma especialização completa para bool que imprima texto legível por humanos em vez de 1 ou 0:
- O método format() deve imprimir: Boolean: true ou Boolean: false
Crie uma especialização completa para const char* que adicione aspas ao redor das strings:
- O método format() deve imprimir: String: "<value>"
Crie também um template de função chamado formatPair que recebe dois valores do mesmo tipo e os imprime juntos como: Pair: [<first>, <second>]

Crie uma especialização de formatPair para const char* que envolva cada string em aspas: Pair: ["<first>", "<second>"]
main.cpp: Leia quatro entradas (cada uma em uma linha separada):
1. Um número inteiro
2. Um double
3. Um booleano como string ("true" ou "false")
4. Um valor de string
Demonstre seus formatadores criando objetos Formatter apropriados e chamando format() para cada tipo:
1. Formate o inteiro usando Formatter<int>
2. Formate o double usando Formatter<double>
3. Formate o booleano usando Formatter<bool> (converta a entrada da string para um bool primeiro)
4. Formate a string usando Formatter<const char*>
Em seguida, demonstre a especialização do template de função:
1. Chame formatPair com dois inteiros: 10 e 20
2. Chame formatPair com duas C-strings: "hello" e "world"

Por exemplo, com as entradas 42, 3.14, "true", e "Hello":

Value: 42
Value: 3.14
Boolean: true
String: "Hello"
Pair: [10, 20]
Pair: ["hello", "world"]

Observe como o template genérico trata inteiros e doubles de forma idêntica, enquanto as versões especializadas para bool e const char* fornecem formatação personalizada. O compilador seleciona automaticamente a correspondência mais específica para cada tipo que você usa.

Folha de consulta

A especialização de template permite que você forneça implementações personalizadas para tipos específicos, mantendo uma versão genérica para todos os outros tipos.

Sintaxe de Especialização Total

Declare uma especialização com uma lista de parâmetros de template vazia template <> e especifique o tipo concreto:

// Template primário
template <typename T>
class Printer {
public:
    void print(T value) {
        std::cout << value << std::endl;
    }
};

// Especialização total para const char*
template <>
class Printer<const char*> {
public:
    void print(const char* value) {
        std::cout << "String: " << value << std::endl;
    }
};

Especialização de Template de Função

Templates de função também podem ser especializados:

template <typename T>
bool isEqual(T a, T b) {
    return a == b;
}

template <>
bool isEqual<const char*>(const char* a, const char* b) {
    return std::strcmp(a, b) == 0;
}

Seleção do Compilador

O compilador sempre prefere a correspondência mais específica - se uma especialização existir para o tipo exato que está sendo usado, ela será escolhida em vez do template genérico.

Experimente você mesmo

#include <iostream>
#include <string>
#include "Formatter.h"

using namespace std;

int main() {
    // Ler as entradas
    int intVal;
    double doubleVal;
    string boolStr;
    string strVal;
    
    cin >> intVal;
    cin >> doubleVal;
    cin >> boolStr;
    cin >> strVal;
    
    // Converter string para bool
    bool boolVal = (boolStr == "true");
    
    // TODO: Criar Formatter<int> e formatar o inteiro
    
    // TODO: Criar Formatter<double> e formatar o double
    
    // TODO: Criar Formatter<bool> e formatar o booleano
    
    // TODO: Criar Formatter<const char*> e formatar a string
    // Dica: Use strVal.c_str() para obter const char*
    
    // TODO: Chamar formatPair com dois inteiros: 10 e 20
    
    // TODO: Chamar formatPair com duas C-strings: "hello" e "world"
    
    return 0;
}