Builder Pattern

The Builder Pattern is a creational design pattern that separates the construction of a complex object from its representation, allowing the same construction process to create different representations. It is particularly useful when an object needs to be created with many possible configurations or when the construction process involves multiple steps. Instead of creating the object directly, the client code uses a “builder” object to construct the object step by step.

What is Builder Pattern

The Builder Pattern addresses the problem of creating complex objects that have many optional parameters or require a specific construction order. Without the Builder Pattern, you might end up with a constructor with a large number of parameters (telescoping constructor) or a complex initialization procedure. This can make the code difficult to read, understand, and maintain. Moreover, it violates the Single Responsibility Principle, because the class is responsible for both its representation and its construction.

The Builder Pattern solves this by:

Encapsulating object construction: The construction logic is moved from the class itself into separate builder classes.
Step-by-step construction: The construction process is broken down into a series of steps, allowing for more control and flexibility.
Different representations: The same construction process can be used to create different representations of the object.

In-depth Explanations:

Director: The Director class is an optional element in the Builder Pattern. It defines the order in which the builder steps should be executed. It decouples the client from the specific building steps, allowing the client to simply request the construction of a specific object type without knowing the details of the construction process.
Abstract Builder: Defines the interface for creating parts of a Product object. It typically includes methods for setting the different attributes of the product and a method for retrieving the final Product object.
Concrete Builders: Implement the Builder interface to construct and assemble the parts of the product. Each concrete builder is responsible for creating a specific representation of the product.
Product: Represents the complex object being constructed. It can be a class with many attributes or a complex data structure.

Edge Cases:

Simple Objects: The Builder Pattern might be overkill for simple objects with only a few attributes. In such cases, a simple constructor or factory method might be sufficient.
Immutable Objects: The Builder Pattern is particularly well-suited for creating immutable objects, as it allows you to set all the attributes of the object during construction and then prevent them from being modified later.
Complex Construction Logic: If the construction logic is very complex and involves many dependencies, the Builder Pattern can help to simplify the code and make it more maintainable.

Performance Considerations:

The Builder Pattern introduces additional classes and objects, which can have a slight performance overhead. However, this overhead is usually negligible compared to the benefits of improved code organization and maintainability.
The creation of the builder object itself can also have a small performance impact. Consider reusing builder objects if you need to create multiple objects of the same type.
In some cases, the Builder Pattern can actually improve performance by allowing you to optimize the construction process for specific object configurations.

Syntax and Usage

The Builder Pattern typically involves the following classes:

Product: The complex object to be constructed.
Builder (Abstract Builder): An interface or abstract class defining the methods for building the different parts of the product.
ConcreteBuilder: Concrete implementations of the Builder interface, each responsible for building a specific representation of the product.
Director (Optional): A class that orchestrates the construction process by calling the builder methods in a specific order.


class Product {
public:
  void setPartA(const std::string& partA) { partA_ = partA; }
  void setPartB(const std::string& partB) { partB_ = partB; }
  void setPartC(const std::string& partC) { partC_ = partC; }
 
  void display() const {
    std::cout << "Part A: " << partA_ << std::endl;
    std::cout << "Part B: " << partB_ << std::endl;
    std::cout << "Part C: " << partC_ << std::endl;
  }
 
private:
  std::string partA_;
  std::string partB_;
  std::string partC_;
};
 
class Builder {
public:
  virtual void buildPartA() = 0;
  virtual void buildPartB() = 0;
  virtual void buildPartC() = 0;
  virtual Product getResult() = 0;
  virtual ~Builder() = default;
};
 
class ConcreteBuilder1 : public Builder {
public:
  ConcreteBuilder1() : product_(new Product()) {}
 
  void buildPartA() override { product_->setPartA("Part A1"); }
  void buildPartB() override { product_->setPartB("Part B1"); }
  void buildPartC() override { product_->setPartC("Part C1"); }
 
  Product getResult() override { return *product_; }
  ~ConcreteBuilder1() override { delete product_; }
 
private:
  Product* product_;
};
 
class Director {
public:
  void setBuilder(Builder* builder) { builder_ = builder; }
 
  void construct() {
    builder_->buildPartA();
    builder_->buildPartB();
    builder_->buildPartC();
  }
 
private:
  Builder* builder_;
};
 
int main() {
  Director director;
  ConcreteBuilder1 builder;
  director.setBuilder(&builder);
  director.construct();
  Product product = builder.getResult();
  product.display();
  return 0;
}

Basic Example

Let’s say we want to build a Computer object. A Computer can have different configurations (e.g., different CPU, RAM, storage).


#include <iostream>
#include <string>
 
class Computer {
public:
  void setCPU(const std::string& cpu) { cpu_ = cpu; }
  void setRAM(const std::string& ram) { ram_ = ram; }
  void setStorage(const std::string& storage) { storage_ = storage; }
  void setGraphicsCard(const std::string& graphicsCard) { graphicsCard_ = graphicsCard; }
  void setOperatingSystem(const std::string& os) { os_ = os; }
 
  void display() const {
    std::cout << "CPU: " << cpu_ << std::endl;
    std::cout << "RAM: " << ram_ << std::endl;
    std::cout << "Storage: " << storage_ << std::endl;
    std::cout << "Graphics Card: " << graphicsCard_ << std::endl;
    std::cout << "Operating System: " << os_ << std::endl;
  }
 
private:
  std::string cpu_;
  std::string ram_;
  std::string storage_;
  std::string graphicsCard_;
  std::string os_;
};
 
class ComputerBuilder {
public:
  virtual ComputerBuilder& setCPU(const std::string& cpu) = 0;
  virtual ComputerBuilder& setRAM(const std::string& ram) = 0;
  virtual ComputerBuilder& setStorage(const std::string& storage) = 0;
  virtual ComputerBuilder& setGraphicsCard(const std::string& graphicsCard) = 0;
  virtual ComputerBuilder& setOperatingSystem(const std::string& os) = 0;
  virtual Computer getResult() = 0;
  virtual ~ComputerBuilder() = default;
};
 
class GamingComputerBuilder : public ComputerBuilder {
public:
  GamingComputerBuilder() : computer_(new Computer()) {}
 
  ComputerBuilder& setCPU(const std::string& cpu) override { computer_->setCPU(cpu); return *this; }
  ComputerBuilder& setRAM(const std::string& ram) override { computer_->setRAM(ram); return *this; }
  ComputerBuilder& setStorage(const std::string& storage) override { computer_->setStorage(storage); return *this; }
  ComputerBuilder& setGraphicsCard(const std::string& graphicsCard) override { computer_->setGraphicsCard(graphicsCard); return *this; }
  ComputerBuilder& setOperatingSystem(const std::string& os) override { computer_->setOperatingSystem(os); return *this; }
 
  Computer getResult() override { return *computer_; }
  ~GamingComputerBuilder() override { delete computer_; }
 
private:
  Computer* computer_;
};
 
int main() {
  GamingComputerBuilder builder;
  Computer gamingComputer = builder.setCPU("Intel i9-13900K")
                                .setRAM("32GB DDR5")
                                .setStorage("2TB NVMe SSD")
                                .setGraphicsCard("NVIDIA RTX 4090")
                                .setOperatingSystem("Windows 11")
                                .getResult();
 
  gamingComputer.display();
 
  return 0;
}

This code demonstrates a basic implementation of the Builder Pattern for constructing a Computer object. The Computer class represents the complex object we want to build. The ComputerBuilder is an abstract class that defines the interface for building the different parts of the computer. The GamingComputerBuilder is a concrete implementation of the ComputerBuilder that builds a gaming computer. The client code creates a GamingComputerBuilder object and then uses its methods to set the different attributes of the computer. Finally, it calls the getResult() method to retrieve the constructed Computer object. Method chaining is used for a fluent interface.

Advanced Example

Now, let’s add a Director class to orchestrate the construction of different types of computers. This allows the client code to request a specific type of computer without knowing the details of the construction process.


#include <iostream>
#include <string>
 
// Same Computer and ComputerBuilder classes as in the Basic Example
 
class Computer {
public:
  void setCPU(const std::string& cpu) { cpu_ = cpu; }
  void setRAM(const std::string& ram) { ram_ = ram; }
  void setStorage(const std::string& storage) { storage_ = storage; }
  void setGraphicsCard(const std::string& graphicsCard) { graphicsCard_ = graphicsCard; }
  void setOperatingSystem(const std::string& os) { os_ = os; }
 
  void display() const {
    std::cout << "CPU: " << cpu_ << std::endl;
    std::cout << "RAM: " << ram_ << std::endl;
    std::cout << "Storage: " << storage_ << std::endl;
    std::cout << "Graphics Card: " << graphicsCard_ << std::endl;
    std::cout << "Operating System: " << os_ << std::endl;
  }
 
private:
  std::string cpu_;
  std::string ram_;
  std::string storage_;
  std::string graphicsCard_;
  std::string os_;
};
 
class ComputerBuilder {
public:
  virtual ComputerBuilder& setCPU(const std::string& cpu) = 0;
  virtual ComputerBuilder& setRAM(const std::string& ram) = 0;
  virtual ComputerBuilder& setStorage(const std::string& storage) = 0;
  virtual ComputerBuilder& setGraphicsCard(const std::string& graphicsCard) = 0;
  virtual ComputerBuilder& setOperatingSystem(const std::string& os) = 0;
  virtual Computer getResult() = 0;
  virtual ~ComputerBuilder() = default;
};
 
class GamingComputerBuilder : public ComputerBuilder {
public:
  GamingComputerBuilder() : computer_(new Computer()) {}
 
  ComputerBuilder& setCPU(const std::string& cpu) override { computer_->setCPU(cpu); return *this; }
  ComputerBuilder& setRAM(const std::string& ram) override { computer_->setRAM(ram); return *this; }
  ComputerBuilder& setStorage(const std::string& storage) override { computer_->setStorage(storage); return *this; }
  ComputerBuilder& setGraphicsCard(const std::string& graphicsCard) override { computer_->setGraphicsCard(graphicsCard); return *this; }
  ComputerBuilder& setOperatingSystem(const std::string& os) override { computer_->setOperatingSystem(os); return *this; }
 
  Computer getResult() override { return *computer_; }
  ~GamingComputerBuilder() override { delete computer_; }
 
private:
  Computer* computer_;
};
 
class OfficeComputerBuilder : public ComputerBuilder {
public:
    OfficeComputerBuilder() : computer_(new Computer()) {}
 
    ComputerBuilder& setCPU(const std::string& cpu) override { computer_->setCPU(cpu); return *this; }
    ComputerBuilder& setRAM(const std::string& ram) override { computer_->setRAM(ram); return *this; }
    ComputerBuilder& setStorage(const std::string& storage) override { computer_->setStorage(storage); return *this; }
    ComputerBuilder& setGraphicsCard(const std::string& graphicsCard) override { computer_->setGraphicsCard(graphicsCard); return *this; }
    ComputerBuilder& setOperatingSystem(const std::string& os) override { computer_->setOperatingSystem(os); return *this; }
 
    Computer getResult() override { return *computer_; }
    ~OfficeComputerBuilder() override { delete computer_; }
 
private:
    Computer* computer_;
};
 
 
class ComputerDirector {
public:
  void constructGamingComputer(ComputerBuilder& builder) {
    builder.setCPU("Intel i9-13900K")
           .setRAM("32GB DDR5")
           .setStorage("2TB NVMe SSD")
           .setGraphicsCard("NVIDIA RTX 4090")
           .setOperatingSystem("Windows 11");
  }
 
    void constructOfficeComputer(ComputerBuilder& builder) {
        builder.setCPU("Intel i5-12400")
            .setRAM("16GB DDR4")
            .setStorage("512GB SATA SSD")
            .setGraphicsCard("Integrated Graphics")
            .setOperatingSystem("Windows 10");
    }
};
 
int main() {
  ComputerDirector director;
  GamingComputerBuilder gamingBuilder;
  OfficeComputerBuilder officeBuilder;
 
  director.constructGamingComputer(gamingBuilder);
  Computer gamingComputer = gamingBuilder.getResult();
  std::cout << "Gaming Computer:" << std::endl;
  gamingComputer.display();
 
  director.constructOfficeComputer(officeBuilder);
  Computer officeComputer = officeBuilder.getResult();
  std::cout << "\nOffice Computer:" << std::endl;
  officeComputer.display();
 
  return 0;
}

In this advanced example, we’ve introduced a ComputerDirector class. This class defines methods for constructing specific types of computers, such as a gaming computer and an office computer. The constructGamingComputer and constructOfficeComputer methods take a ComputerBuilder as an argument and use it to build the computer step by step.

Common Use Cases

Creating complex objects with many optional parameters.
Building different representations of the same object using the same construction process.
Simplifying the construction process of objects with complex dependencies.

Best Practices

Define a clear and concise Builder interface.
Use method chaining for a fluent interface.
Consider using a Director class to orchestrate the construction process.
Keep the Builder classes focused on the construction logic.

Common Pitfalls

Using the Builder Pattern for simple objects.
Creating overly complex Builder classes.
Failing to define a clear and concise Builder interface.

Key Takeaways

The Builder Pattern separates the construction of a complex object from its representation.
It allows you to build different representations of the same object using the same construction process.
It simplifies the construction process of objects with complex dependencies.
It promotes flexibility and maintainability.