Modèle Builder

Fait partie de la section Programmation Orientée Objet du Journey C++ de Coddy. Leçon 93 sur 104.

Le pattern Builder sépare la construction d’un objet complexe de sa représentation, ce qui vous permet de créer différentes configurations étape par étape. Cela est particulièrement utile lorsqu’un objet possède de nombreux paramètres facultatifs ou nécessite une séquence de construction spécifique.

Au lieu d’un constructeur avec de nombreux paramètres (qui devient déroutant), le Builder fournit des méthodes claires et nommées pour chaque option de configuration :

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

Chaque méthode setter renvoie une référence au générateur (return *this), ce qui permet de chaîner les méthodes pour obtenir une interface fluide. La méthode build() finalise et renvoie l’objet construit.

Utilisez Builder lorsque vous construisez des objets comportant de nombreux composants facultatifs, lorsque vous souhaitez un code de construction lisible ou lorsque le même processus de construction doit créer différentes représentations.

Défi

Facile

Construisons un système de construction d'ordinateurs qui permet aux utilisateurs de configurer des PC personnalisés étape par étape. C'est un scénario idéal pour le patron Builder : les ordinateurs comportent de nombreux composants facultatifs, et nous voulons disposer d'une manière claire et lisible d'assembler différentes configurations.

Vous organiserez votre code dans trois fichiers :

Computer.h : définissez la classe produit qui représente un ordinateur entièrement configuré.
Votre classe Computer doit stocker ces composants en tant que membres privés : cpu (chaîne de caractères), ram (chaîne de caractères), storage (chaîne de caractères), gpu (chaîne de caractères) et hasWifi (booléen). Initialisez hasWifi à false et les chaînes à une valeur vide par défaut.

Ajoutez une méthode publique appelée showSpecs() qui affiche la configuration de l'ordinateur. Pour chaque composant qui a été défini (chaîne non vide), affichez-le sur sa propre ligne. La capacité Wi-Fi ne doit être affichée que si elle est activée.
ComputerBuilder.h : créez la classe builder qui construit les ordinateurs avec une interface fluide.
Votre classe ComputerBuilder doit posséder un membre privé Computer qu'elle construit progressivement. Implémentez ces méthodes, chacune retournant une référence vers le builder afin de permettre le chaînage des méthodes :
- setCPU(const std::string& cpu)
- setRAM(const std::string& ram)
- setStorage(const std::string& storage)
- setGPU(const std::string& gpu)
- addWifi() : active la capacité Wi-Fi
Implémentez également une méthode build() qui retourne l'objet Computer terminé et réinitialise le builder pour permettre sa réutilisation.
main.cpp : assemblez tous les éléments pour construire un ordinateur personnalisé.
Lisez quatre entrées :
1. Modèle du CPU (chaîne de caractères)
2. Caractéristiques de la RAM (chaîne de caractères)
3. Caractéristiques du stockage (chaîne de caractères)
4. Indiquer s'il faut inclure le Wi-Fi : yes ou no
Utilisez ComputerBuilder pour construire un ordinateur avec le CPU, la RAM et le stockage fournis. Si l'entrée Wi-Fi est yes, appelez également addWifi(). Notez qu'aucun GPU n'est spécifié dans cette configuration : le builder doit gérer les composants facultatifs avec élégance.

Après la construction, appelez showSpecs() sur l'ordinateur obtenu pour afficher sa configuration.

La méthode showSpecs() doit produire le format suivant (en affichant uniquement les composants qui ont été définis) :

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

Par exemple, avec les entrées Intel i7-12700K, 32GB DDR5, 1TB NVMe SSD et yes :

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

Avec les entrées AMD Ryzen 5 5600X, 16GB DDR4, 512GB SSD et no :

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

Remarquez comment le patron Builder rend le processus de construction lisible et flexible. Vous pouvez facilement ajouter ou ignorer des composants, et le chaînage des méthodes produit un code clair qui se documente lui-même. La ligne du GPU n'apparaît pas, car nous ne l'avons jamais défini, ce qui montre comment les builders gèrent naturellement les composants facultatifs.

Essayez vous-même

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

using namespace std;

int main() {
    // Lire les entrées
    string cpu, ram, storage, wifiChoice;
    getline(cin, cpu);
    getline(cin, ram);
    getline(cin, storage);
    getline(cin, wifiChoice);

    // TODO: Créer une instance de ComputerBuilder
    
    // TODO: Utiliser le chaînage de méthodes pour définir CPU, RAM et storage
    
    // TODO: Si wifiChoice est "yes", appeler aussi addWifi()
    
    // TODO: Appeler build() pour obtenir l'objet Computer
    
    // TODO: Appeler showSpecs() sur l'ordinateur construit pour afficher la configuration

    return 0;
}