Builder Pattern (Classic GoF + Modern Fluent Style)

Classic GoF Builder (With Director)

class Computer {
public:
    std::string cpu;
    int ram;
    int storage;

    void show() const {
        std::cout << "Computer: "
                  << cpu << ", RAM: "
                  << ram << ", Storage: "
                  << storage << std::endl;
    }
};

class ComputerManual {
public:
    std::string description;

    void show() const {
        std::cout << "Manual: "
                  << description
                  << std::endl;
    }


 
};

Abstract Builder

class Builder {
public:
    virtual void buildCPU() = 0;
    virtual void buildRAM() = 0;
    virtual void buildStorage() = 0;
    virtual ~Builder() = default;
};

class ComputerBuilder : public Builder {
private:
    Computer product;

public:
    void buildCPU() override {
        product.cpu = "Intel i7";
    }

    void buildRAM() override {
        product.ram = 16;
    }

    void buildStorage() override {
        product.storage = 512;
    }

    Computer getResult() { return product; }
};

class ManualBuilder : public Builder {
private:
    ComputerManual manual;

public:
    void buildCPU() override {
        manual.description += "CPU: Intel i7\n";
    }

    void buildRAM() override {
        manual.description += "RAM: 16GB\n";
    }

    void buildStorage() override {
        manual.description += "Storage: 512GB\n";
    }

    ComputerManual getResult() { return manual; }
};

Director (Construction Recipe)

class Director {
public:
    void construct(Builder& builder) {
        builder.buildCPU();
        builder.buildRAM();
        builder.buildStorage();
    }
};

Usage

int main() {
    Director director;

    ComputerBuilder computerBuilder;
    director.construct(computerBuilder);
    Computer pc = computerBuilder.getResult();
    pc.show();

    ManualBuilder manualBuilder;
    director.construct(manualBuilder);
    ComputerManual manual = manualBuilder.getResult();
    manual.show();
}

Notice: Same construction process → Different representations.

Classic GoF Builder (Without Director)

In many real-world C++ systems, the Director is optional. The client can directly control the construction steps while still preserving the Builder abstraction and multiple representations.

This version still follows the GoF structure:

• Product
• Abstract Builder
• Concrete Builder

But the client controls the build sequence, not the Director.

Product

class House {
public:
    std::string foundation;
    std::string structure;
    std::string roof;

    void show() const {
        std::cout << "House with "
                  << foundation << ", "
                  << structure << ", "
                  << roof << std::endl;
    }
};

Abstract Builder

class HouseBuilder {
public:
    virtual void buildFoundation() = 0;
    virtual void buildStructure() = 0;
    virtual void buildRoof() = 0;
    virtual ~HouseBuilder() = default;
};

Concrete Builder

class ConcreteHouseBuilder : public HouseBuilder {
private:
    House house;

public:
    void buildFoundation() override {
        house.foundation = "Concrete Foundation";
    }

    void buildStructure() override {
        house.structure = "Brick Structure";
    }

    void buildRoof() override {
        house.roof = "Tile Roof";
    }

    House getResult() {
        return house;
    }
};

Usage (Client Controls Build Order)

int main() {

    ConcreteHouseBuilder builder;

    // Client directly controls construction sequence
    builder.buildFoundation();
    builder.buildStructure();
    builder.buildRoof();

    House house = builder.getResult();
    house.show();

    return 0;
}

Key Characteristics of GoF Builder (Without Director)

• No Director class.
• Client calls build steps directly.
• Still supports multiple representations by using different ConcreteBuilders.
• Lower abstraction overhead than the Director version.

When to Use a Builder Without a Director

• The Construction process is simple.
• No need to reuse standardized build recipes.
• Client must dynamically control build order.
• The system is not framework-level complex.

Comparison: With vs Without Director

Modern Fluent Builder (Method Chaining) — C++ Example

Modern C++ frequently uses a simpler approach: the Fluent Builder.

The fluent builder focuses on readability and optional configuration. Each setXxx() method returns *this so calls can be chained. The build() method returns the final product.

Product — Computer

#include <iostream>
#include <string>

class Computer {
public:
    std::string cpu;
    std::string gpu;
    int ramGB = 0;
    int storageGB = 0;
    bool wifi = false;
    bool bluetooth = false;

    void show() const {
        std::cout
            << "Computer: "
            << "CPU=" << cpu
            << ", GPU=" << gpu
            << ", RAM=" << ramGB
            << ", Storage=" << storageGB
            << ", WiFi=" << (wifi ? "Yes" : "No")
            << ", Bluetooth=" << (bluetooth ? "Yes" : "No")
            << std::endl;
    }
};

Fluent Builder — ComputerBuilder

Each method returns *this to enable method chaining. The build() function returns the final Computer.

class ComputerBuilder {
private:
    Computer computer;

public:
    ComputerBuilder& reset() {
        computer = Computer{};
        return *this;
    }

    ComputerBuilder& setCPU(const std::string& value) {
        computer.cpu = value;
        return *this;
    }

    ComputerBuilder& setGPU(const std::string& value) {
        computer.gpu = value;
        return *this;
    }

    ComputerBuilder& setRAM(int value) {
        computer.ramGB = value;
        return *this;
    }

    ComputerBuilder& setStorage(int value) {
        computer.storageGB = value;
        return *this;
    }

    ComputerBuilder& enableWiFi(bool value = true) {
        computer.wifi = value;
        return *this;
    }

    ComputerBuilder& enableBluetooth(bool value = true) {
        computer.bluetooth = value;
        return *this;
    }

    Computer build() {
        // Optional validation logic:
        // if (computer.cpu.empty()) throw std::runtime_error("CPU required");
        return computer;
    }
};

Usage (Client Code)

int main() {

    Computer gamingPC = ComputerBuilder{}
        .setCPU("Intel i9")
        .setGPU("RTX 4090")
        .setRAM(32)
        .setStorage(2000)
        .enableWiFi()
        .enableBluetooth()
        .build();

    gamingPC.show();

    // Reusing builder
    ComputerBuilder builder;

    Computer officePC = builder.reset()
        .setCPU("Intel i5")
        .setGPU("Integrated GPU")
        .setRAM(16)
        .setStorage(512)
        .enableWiFi()
        .build();

    officePC.show();

    return 0;
}

Optional — Fluent Builder Interface

Most Fluent Builders do not require an abstract interface. However, if multiple builder implementations are needed, you may introduce an interface like this:

class IComputerBuilder {
public:
    virtual ~IComputerBuilder() = default;

    virtual IComputerBuilder& setCPU(const std::string&) = 0;
    virtual IComputerBuilder& setGPU(const std::string&) = 0;
    virtual IComputerBuilder& setRAM(int) = 0;
    virtual IComputerBuilder& setStorage(int) = 0;
    virtual Computer build() = 0;
};

The concrete builder would implement this interface and still return *this (as a reference to the interface).

Key Characteristics

• Readable configuration-style API.
• Solves the telescoping constructor problem.
• No Director required.
• Common in modern C++ application-level code.

Fluent Builder + Immutable Computer (Advanced Modern C++ Design)

A common advanced design is to combine a fluent builder with an immutable product. This prevents partially-initialized states and reduces bugs caused by global mutations after construction.

• Immutable Product: fields cannot be modified after construction.
• Builder: collects configuration, validates it, then constructs the immutable product.
• Best for: configuration objects, request objects, security-sensitive settings, multi-threaded read-only sharing.

Each step returns a new builder with an updated state.

Useful for:

• thread safety
• parallel building
• functional programming style

Immutable Product — Computer

The product has private fields and only provides getters. The constructor is private to enforce builder-only construction.

#include <string>
#include <stdexcept>

class ImmutableComputer {
private:
    const std::string cpu_;
    const std::string gpu_;
    const int ramGB_;
    const int storageGB_;
    const bool wifi_;
    const bool bluetooth_;

    // Only the builder can call this constructor
    ImmutableComputer(std::string cpu,
                      std::string gpu,
                      int ramGB,
                      int storageGB,
                      bool wifi,
                      bool bluetooth)
        : cpu_(std::move(cpu)),
          gpu_(std::move(gpu)),
          ramGB_(ramGB),
          storageGB_(storageGB),
          wifi_(wifi),
          bluetooth_(bluetooth) {}

public:
    // Getters only (read-only)
    const std::string& cpu() const { return cpu_; }
    const std::string& gpu() const { return gpu_; }
    int ramGB() const { return ramGB_; }
    int storageGB() const { return storageGB_; }
    bool wifi() const { return wifi_; }
    bool bluetooth() const { return bluetooth_; }

    // Builder needs access to the private constructor
    class Builder;
};

Fluent Builder with Validation

The builder stores the mutable configuration, validates it, and then constructs the immutable object in build().

class ImmutableComputer::Builder {
private:
    std::string cpu;
    std::string gpu = "Integrated GPU";
    int ramGB = 8;
    int storageGB = 256;
    bool wifi = false;
    bool bluetooth = false;

public:
    Builder& setCPU(const std::string& value) {
        cpu = value;
        return *this;
    }

    Builder& setGPU(const std::string& value) {
        gpu = value;
        return *this;
    }

    Builder& setRAM(int value) {
        ramGB = value;
        return *this;
    }

    Builder& setStorage(int value) {
        storageGB = value;
        return *this;
    }

    Builder& enableWiFi(bool value = true) {
        wifi = value;
        return *this;
    }

    Builder& enableBluetooth(bool value = true) {
        bluetooth = value;
        return *this;
    }

    ImmutableComputer build() const {
        // Validation examples:
        if (cpu.empty()) {
            throw std::runtime_error("CPU is required.");
        }
        if (ramGB <= 0 || storageGB <= 0) {
            throw std::runtime_error("RAM and Storage must be positive.");
        }

        return ImmutableComputer(cpu, gpu, ramGB, storageGB, wifi, bluetooth);
    }
};

Usage

#include <iostream>

int main() {
    try {
        ImmutableComputer pc = ImmutableComputer::Builder{}
            .setCPU("Intel i9")
            .setGPU("RTX 4090")
            .setRAM(32)
            .setStorage(2000)
            .enableWiFi()
            .enableBluetooth()
            .build();

        std::cout << "ImmutableComputer built: CPU=" << pc.cpu()
                  << ", RAM=" << pc.ramGB()
                  << ", WiFi=" << (pc.wifi() ? "Yes" : "No")
                  << std::endl;

        // pc.cpu_ = "AMD"; // NOT allowed (private + const)
    }
    catch (const std::exception& ex) {
        std::cerr << "Build failed: " << ex.what() << std::endl;
    }
}

Why Immutable + Builder is Valuable

• Safety: prevents accidental mutation after construction.
• Validity: the builder can enforce invariants before object creation.
• Concurrency: immutable objects are easier to share across threads (read-only).
• Maintainability: construction rules stay centralized in the builder.