Padrão Builder

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

O padrão Builder separa a construção de um objeto complexo de sua representação, permitindo que você crie diferentes configurações passo a passo. Isso é especialmente útil quando um objeto tem muitos parâmetros opcionais ou exige uma sequência específica de construção.

Em vez de um construtor com muitos parâmetros (o que se torna confuso), o Builder fornece métodos claros e nomeados para cada opção de configuração:

#include <iostream>
#include <string>

class Pizza {
public:
    std::string dough;
    std::string sauce;
    std::string topping;
    bool cheese;
    
    void describe() const {
        std::cout << dough << " dough, " << sauce << " sauce, "
                  << topping << (cheese ? ", with cheese" : "") << "\n";
    }
};

class PizzaBuilder {
private:
    Pizza pizza;
    
public:
    PizzaBuilder& setDough(const std::string& d) {
        pizza.dough = d;
        return *this;
    }
    
    PizzaBuilder& setSauce(const std::string& s) {
        pizza.sauce = s;
        return *this;
    }
    
    PizzaBuilder& setTopping(const std::string& t) {
        pizza.topping = t;
        return *this;
    }
    
    PizzaBuilder& addCheese() {
        pizza.cheese = true;
        return *this;
    }
    
    Pizza build() { return pizza; }
};

int main() {
    Pizza margherita = PizzaBuilder()
        .setDough("thin")
        .setSauce("tomato")
        .setTopping("basil")
        .addCheese()
        .build();
    
    margherita.describe();
}

Cada método setter retorna uma referência ao builder (return *this), permitindo o encadeamento de métodos para uma interface fluente. O método build() finaliza e retorna o objeto construído.

Use Builder ao construir objetos com muitos componentes opcionais, quando quiser um código de construção legível ou quando o mesmo processo de construção precisar criar diferentes representações.

Desafio

Fácil

Vamos criar um sistema Computer Builder que permita aos usuários configurar PCs personalizados passo a passo. Este é um cenário perfeito para o padrão Builder: os computadores têm muitos componentes opcionais, e queremos uma maneira limpa e legível de montar diferentes configurações.

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

Computer.h: Defina a classe de produto que representa um computador totalmente configurado.
Sua classe Computer deve armazenar estes componentes como membros privados: cpu (string), ram (string), storage (string), gpu (string) e hasWifi (booleano). Inicialize hasWifi como false e as strings como vazias por padrão.

Adicione um método público chamado showSpecs() que exiba a configuração do computador. Para cada componente que tiver sido definido (string não vazia), imprima-o em sua própria linha. A capacidade de wifi só deve ser impressa se estiver habilitada.
ComputerBuilder.h: Crie a classe construtora que monta computadores com uma interface fluente.
Sua classe ComputerBuilder deve ter um membro privado Computer que ela monta gradualmente. Implemente estes métodos, cada um retornando uma referência à construtora para permitir o encadeamento de métodos:
- setCPU(const std::string& cpu)
- setRAM(const std::string& ram)
- setStorage(const std::string& storage)
- setGPU(const std::string& gpu)
- addWifi(): habilita a capacidade de wifi
Implemente também um método build() que retorne o objeto Computer concluído e redefina a construtora para possível reutilização.
main.cpp: Reúna tudo para montar um computador personalizado.
Leia quatro entradas:
1. Modelo da CPU (string)
2. Especificação da RAM (string)
3. Especificação do armazenamento (string)
4. Se deve incluir wifi: yes ou no
Use ComputerBuilder para construir um computador com a CPU, a RAM e o armazenamento fornecidos. Se a entrada de wifi for yes, chame também addWifi(). Observe que nenhuma GPU é especificada nesta configuração: a construtora deve lidar normalmente com componentes opcionais.

Depois da construção, chame showSpecs() no computador resultante para exibir sua configuração.

O método showSpecs() deve produzir neste formato (mostrando apenas os componentes que foram definidos):

CPU: [value]
RAM: [value]
Storage: [value]
GPU: [value]
Wifi: Enabled

Por exemplo, com as entradas Intel i7-12700K, 32GB DDR5, 1TB NVMe SSD e yes:

CPU: Intel i7-12700K
RAM: 32GB DDR5
Storage: 1TB NVMe SSD
Wifi: Enabled

Com as entradas AMD Ryzen 5 5600X, 16GB DDR4, 512GB SSD e no:

CPU: AMD Ryzen 5 5600X
RAM: 16GB DDR4
Storage: 512GB SSD

Observe como o padrão Builder torna o processo de construção legível e flexível. Você pode adicionar ou ignorar componentes facilmente, e o encadeamento de métodos cria um código claro e autoexplicativo. A linha da GPU não aparece porque nunca a definimos, demonstrando como as construtoras lidam naturalmente com componentes opcionais.

Experimente você mesmo

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

using namespace std;

int main() {
    // Ler entradas
    string cpu, ram, storage, wifiChoice;
    getline(cin, cpu);
    getline(cin, ram);
    getline(cin, storage);
    getline(cin, wifiChoice);

    // TODO: Crie uma instância de ComputerBuilder
    
    // TODO: Use encadeamento de métodos para definir CPU, RAM e storage
    
    // TODO: Se wifiChoice for "yes", também chame addWifi()
    
    // TODO: Chame build() para obter o objeto Computer
    
    // TODO: Chame showSpecs() no computador construído para exibir a configuração

    return 0;
}