Padrão Template Method

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

O padrão Template Method define o esqueleto de um algoritmo em uma classe base, permitindo que as subclasses substituam etapas específicas sem alterar a estrutura geral do algoritmo. Diferentemente de Strategy, que troca algoritmos inteiros, o Template Method mantém o algoritmo fixo e permite a personalização de etapas individuais.

A classe base implementa o método template (o algoritmo) e chama métodos abstratos ou virtuais que as subclasses devem fornecer:

#include <iostream>

class DataProcessor {
public:
    // Método template - define o esqueleto do algoritmo
    void process() {
        loadData();
        processData();
        saveResults();
    }
    
    virtual ~DataProcessor() = default;
    
protected:
    virtual void loadData() = 0;      // Deve ser implementado
    virtual void processData() = 0;   // Deve ser implementado
    
    // Hook - sobrescrita opcional com comportamento padrão
    virtual void saveResults() {
        std::cout << "Saving to default location\n";
    }
};

class CSVProcessor : public DataProcessor {
protected:
    void loadData() override {
        std::cout << "Loading CSV file\n";
    }
    void processData() override {
        std::cout << "Parsing CSV data\n";
    }
};

class JSONProcessor : public DataProcessor {
protected:
    void loadData() override {
        std::cout << "Loading JSON file\n";
    }
    void processData() override {
        std::cout << "Parsing JSON data\n";
    }
    void saveResults() override {
        std::cout << "Saving to cloud storage\n";
    }
};

int main() {
    CSVProcessor csv;
    csv.process();  // Usa o saveResults padrão
    
    JSONProcessor json;
    json.process(); // Usa o saveResults personalizado
}

O método process() é o método template — ele define a sequência fixa de etapas. As subclasses implementam loadData() e processData() de maneira diferente, mas a ordem nunca muda. O método saveResults() é um “hook” — ele tem uma implementação padrão que as subclasses podem substituir opcionalmente.

Use o Template Method quando você tiver um algoritmo com etapas invariáveis, mas precisar de flexibilidade em operações específicas, ou quando quiser evitar a duplicação de código entre classes semelhantes.

Desafio

Fácil

Vamos criar um sistema de Gerador de Relatórios usando o padrão Template Method. Você criará uma estrutura na qual diferentes tipos de relatórios (como relatórios de vendas e relatórios de inventário) seguem o mesmo processo de geração, mas cada tipo de relatório personaliza etapas específicas. Este é um cenário perfeito para o Template Method: o fluxo de trabalho geral permanece fixo, enquanto as etapas individuais variam.

Você organizará seu código em três arquivos:

ReportGenerator.h: Defina a classe base abstrata com o método template.
Crie uma classe ReportGenerator que defina o esqueleto do algoritmo de geração de relatórios. Seu método template generateReport() deve executar estas etapas na ordem:
1. gatherData(): virtual pura, deve ser implementada pelas subclasses
2. formatReport(): virtual pura, deve ser implementada pelas subclasses
3. addHeader(): um hook com comportamento padrão que imprime --- Report ---
4. printReport(): virtual pura, deve ser implementada pelas subclasses
O método addHeader() atua como um hook que as subclasses podem opcionalmente sobrescrever para personalizar o cabeçalho.
Reports.h: Implemente dois geradores de relatórios concretos.
Crie uma classe SalesReport que:
- gatherData() imprime Gathering sales data from database
- formatReport() imprime Formatting sales figures
- printReport() imprime Sales Total: $[amount], em que amount é passado para o construtor
Crie uma classe InventoryReport que:
- gatherData() imprime Scanning inventory records
- formatReport() imprime Organizing inventory by category
- addHeader() sobrescreve o hook para imprimir === Inventory Report ===
- printReport() imprime Items in stock: [count], em que count é passado para o construtor
Ambas as classes devem aceitar seus respectivos valores (amount ou count) por meio de seus construtores.
main.cpp: Demonstre o padrão Template Method.
Leia duas entradas:
1. Valor das vendas (inteiro)
2. Quantidade de itens no inventário (inteiro)
Crie um SalesReport com o valor das vendas e gere o relatório. Em seguida, crie um InventoryReport com a quantidade de itens no inventário e gere o relatório. Imprima uma linha em branco entre os dois relatórios para facilitar a leitura.

Por exemplo, com as entradas 15000 e 250:

Gathering sales data from database
Formatting sales figures
--- Report ---
Sales Total: $15000

Scanning inventory records
Organizing inventory by category
=== Inventory Report ===
Items in stock: 250

Com as entradas 8500 e 120:

Gathering sales data from database
Formatting sales figures
--- Report ---
Sales Total: $8500

Scanning inventory records
Organizing inventory by category
=== Inventory Report ===
Items in stock: 120

Observe como ambos os relatórios seguem exatamente a mesma sequência de etapas definida em generateReport(), mas cada um implementa essas etapas de maneira diferente. O InventoryReport também demonstra a sobrescrita do método hook para personalizar o cabeçalho, enquanto o SalesReport usa o comportamento padrão. Este é o padrão Template Method em ação: a estrutura do algoritmo é fixada na classe base, mas os detalhes são flexíveis.

Experimente você mesmo

#include <iostream>
#include "Reports.h"

using namespace std;

int main() {
    // Ler entradas
    int salesAmount;
    int inventoryCount;
    cin >> salesAmount;
    cin >> inventoryCount;
    
    // TODO: Crie um SalesReport com salesAmount e o gere
    
    // TODO: Imprima uma linha em branco entre os relatórios
    
    // TODO: Create an InventoryReport with inventoryCount and generate it
    
    return 0;
}