The Builder pattern is a creational design pattern that allows you to construct complex objects step by step. It’s useful when you need to create objects with many optional parameters.

The Builder pattern separates the construction of a complex object from its representation, allowing you to create different representations using the same construction process.

  1. Product - The complex object being built (Car)
  2. Builder - Abstract interface defining construction steps (CarBuilder)
  3. Concrete Builder - Implements the building steps (SportsCarBuilder, FamilyCarBuilder)

Example Link to heading

Here’s a complete implementation of the Builder pattern for constructing different types of cars. Each build method returns a reference to the builder (return *this).

auto car = builder.buildEngine()
                 .buildBody()
                 .buildWheels()
                 .getResult();

#include <iostream>
#include <string>
#include <memory>
using namespace std;

// Product: The complex object we want to build
class Car {
private:
    string engine_;
    string body_;
    string wheels_;

public:
    void setEngine(const string& engine) { engine_ = engine; }
    void setBody(const string& body) { body_ = body; }
    void setWheels(const string& wheels) { wheels_ = wheels; }

    void show() const {
        cout << "Car: " << engine_ << ", " << body_ << ", " << wheels_ << endl;
    }
};

// Abstract Builder: Defines the interface for building steps
class CarBuilder {
protected:
    unique_ptr<Car> car_;

public:
    CarBuilder() { car_ = make_unique<Car>(); }
    virtual ~CarBuilder() = default;

    virtual CarBuilder& buildEngine() = 0;
    virtual CarBuilder& buildBody() = 0;
    virtual CarBuilder& buildWheels() = 0;

    unique_ptr<Car> getResult() { return std::move(car_); }
};

// Concrete Builder: Sports Car
class SportsCarBuilder : public CarBuilder {
public:
    CarBuilder& buildEngine() override {
        car_->setEngine("V8 Engine");
        return *this;
    }

    CarBuilder& buildBody() override {
        car_->setBody("Aerodynamic Body");
        return *this;
    }

    CarBuilder& buildWheels() override {
        car_->setWheels("Racing Wheels");
        return *this;
    }
};

// Concrete Builder: Family Car
class FamilyCarBuilder : public CarBuilder {
public:
    CarBuilder& buildEngine() override {
        car_->setEngine("V6 Engine");
        return *this;
    }

    CarBuilder& buildBody() override {
        car_->setBody("Comfortable Body");
        return *this;
    }

    CarBuilder& buildWheels() override {
        car_->setWheels("Standard Wheels");
        return *this;
    }
};

int main() {
    // Direct usage with method chaining
    SportsCarBuilder directBuilder;
    auto directCar = directBuilder.buildEngine()
                                 .buildWheels()
                                 .buildBody()
                                 .getResult();
    directCar->show();

    // Family car example
    FamilyCarBuilder familyBuilder;
    auto familyCar = familyBuilder.buildEngine()
                                 .buildBody()
                                 .buildWheels()
                                 .getResult();
    familyCar->show();

    return 0;
}