Pattern Builder

Fa parte della sezione Programmazione orientata agli oggetti del percorso C++ di Coddy. Lezione 93 di 104.

Il pattern Builder separa la costruzione di un oggetto complesso dalla sua rappresentazione, permettendoti di creare configurazioni diverse passo dopo passo. È particolarmente utile quando un oggetto ha molti parametri opzionali o richiede una sequenza di costruzione specifica.

Invece di un costruttore con molti parametri (che diventa confuso), Builder fornisce metodi chiari e denominati per ogni opzione di configurazione:

#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();
}

Ogni metodo setter restituisce un riferimento al builder (return *this), consentendo di concatenare i metodi per ottenere un’interfaccia fluida. Il metodo build() finalizza e restituisce l’oggetto costruito.

Usa Builder quando costruisci oggetti con molti componenti facoltativi, quando vuoi un codice di costruzione leggibile o quando lo stesso processo di costruzione dovrebbe creare rappresentazioni diverse.

Sfida

Facile

Costruiamo un sistema Computer Builder che consenta agli utenti di configurare PC personalizzati passo dopo passo. È uno scenario perfetto per il pattern Builder: i computer hanno molti componenti opzionali e vogliamo un modo chiaro e leggibile per assemblare configurazioni diverse.

Organizzerai il codice in tre file:

Computer.h: definisci la classe prodotto che rappresenta un computer completamente configurato.
La classe Computer dovrebbe memorizzare questi componenti come membri privati: cpu (stringa), ram (stringa), storage (stringa), gpu (stringa) e hasWifi (booleano). Inizializza hasWifi a false e, per impostazione predefinita, assegna stringhe vuote alle stringhe.

Aggiungi un metodo pubblico chiamato showSpecs() che visualizzi la configurazione del computer. Per ogni componente che è stato impostato (stringa non vuota), stampalo su una riga separata. La funzionalità Wi-Fi dovrebbe essere stampata solo se è abilitata.
ComputerBuilder.h: crea la classe builder che costruisce i computer con un'interfaccia fluida.
La classe ComputerBuilder dovrebbe avere un membro privato Computer che costruisce progressivamente. Implementa questi metodi, ciascuno dei quali restituisce un riferimento al builder per consentire il concatenamento dei metodi:
- setCPU(const std::string& cpu)
- setRAM(const std::string& ram)
- setStorage(const std::string& storage)
- setGPU(const std::string& gpu)
- addWifi(): abilita la funzionalità Wi-Fi
Implementa anche un metodo build() che restituisca l'oggetto Computer completato e ripristini il builder per un eventuale riutilizzo.
main.cpp: metti tutto insieme per costruire un computer personalizzato.
Leggi quattro input:
1. Modello della CPU (stringa)
2. Specifiche della RAM (stringa)
3. Specifiche dello spazio di archiviazione (stringa)
4. Se includere il Wi-Fi: yes o no
Usa ComputerBuilder per costruire un computer con la CPU, la RAM e lo spazio di archiviazione forniti. Se l'input per il Wi-Fi è yes, chiama anche addWifi(). Nota che in questa configurazione non è specificata alcuna GPU: il builder dovrebbe gestire con flessibilità i componenti opzionali.

Dopo averlo costruito, chiama showSpecs() sul computer risultante per visualizzarne la configurazione.

Il metodo showSpecs() dovrebbe produrre un output in questo formato (mostrando solo i componenti impostati):

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

Ad esempio, con gli input Intel i7-12700K, 32GB DDR5, 1TB NVMe SSD e yes:

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

Con gli input AMD Ryzen 5 5600X, 16GB DDR4, 512GB SSD e no:

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

Nota come il pattern Builder renda il processo di costruzione leggibile e flessibile. Puoi aggiungere o saltare facilmente dei componenti e il concatenamento dei metodi produce codice chiaro e autoesplicativo. La riga della GPU non compare perché non l'abbiamo mai impostata: questo dimostra come i builder gestiscano in modo naturale i componenti opzionali.

Provalo tu

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

using namespace std;

int main() {
    // Leggi i valori in input
    string cpu, ram, storage, wifiChoice;
    getline(cin, cpu);
    getline(cin, ram);
    getline(cin, storage);
    getline(cin, wifiChoice);

    // TODO: Crea un'istanza di ComputerBuilder
    
    // TODO: Usa il concatenamento dei metodi per impostare CPU, RAM e la memoria di archiviazione
    
    // TODO: Se wifiChoice è "yes", chiama anche addWifi()
    
    // TODO: Chiama build() per ottenere l'oggetto Computer
    
    // TODO: Chiama showSpecs() sul computer creato per visualizzare la configurazione

    return 0;
}