Builder Pattern in C++: Mastering Creational Design Patterns

4.4 Builder Pattern

In the realm of software design patterns, the Builder Pattern stands out as a powerful technique for constructing complex objects step by step. This pattern is particularly useful when an object needs to be created with numerous optional components or configurations. In this section, we will delve into the intricacies of the Builder Pattern, its implementation in C++, and its role in fluent interface design and Director classes.

Intent of the Builder Pattern

The primary intent of the Builder Pattern is to separate the construction of a complex object from its representation, allowing the same construction process to create different representations. This pattern is ideal when the construction process involves multiple steps or when the object being constructed requires various configurations.

Key Participants

1. Builder: An abstract interface that defines the steps to build the product.
2. ConcreteBuilder: Implements the Builder interface to construct and assemble parts of the product.
3. Director: Constructs an object using the Builder interface.
4. Product: The complex object that is being built.

Applicability

The Builder Pattern is applicable in scenarios where:

• The construction process of an object is complex and involves multiple steps.
• Different representations of the object are needed.
• The construction process needs to be independent of the parts that make up the object.

Implementing the Builder Pattern in C++

Let’s explore how to implement the Builder Pattern in C++ through a practical example. We’ll create a House class that can have various components such as walls, doors, and windows. The construction of a house can vary based on different requirements, making it a perfect candidate for the Builder Pattern.

Step 1: Define the Product

First, we define the House class, which represents the complex object we want to build.

 1#include <iostream>
 2#include <string>
 3
 4class House {
 5public:
 6    void setWalls(const std::string& walls) { walls_ = walls; }
 7    void setDoors(const std::string& doors) { doors_ = doors; }
 8    void setWindows(const std::string& windows) { windows_ = windows; }
 9    void show() const {
10        std::cout << "House with " << walls_ << ", " << doors_ << ", and " << windows_ << ".\n";
11    }
12
13private:
14    std::string walls_;
15    std::string doors_;
16    std::string windows_;
17};

Step 2: Create the Builder Interface

Next, we define the HouseBuilder interface, which specifies the steps required to build a house.

1class HouseBuilder {
2public:
3    virtual ~HouseBuilder() {}
4    virtual void buildWalls() = 0;
5    virtual void buildDoors() = 0;
6    virtual void buildWindows() = 0;
7    virtual House* getHouse() = 0;
8};

Step 3: Implement Concrete Builders

We create concrete builders that implement the HouseBuilder interface. Each concrete builder can create a different type of house.

 1class StoneHouseBuilder : public HouseBuilder {
 2public:
 3    StoneHouseBuilder() { house_ = new House(); }
 4    ~StoneHouseBuilder() { delete house_; }
 5
 6    void buildWalls() override { house_->setWalls("Stone walls"); }
 7    void buildDoors() override { house_->setDoors("Wooden doors"); }
 8    void buildWindows() override { house_->setWindows("Glass windows"); }
 9    House* getHouse() override { return house_; }
10
11private:
12    House* house_;
13};
14
15class WoodenHouseBuilder : public HouseBuilder {
16public:
17    WoodenHouseBuilder() { house_ = new House(); }
18    ~WoodenHouseBuilder() { delete house_; }
19
20    void buildWalls() override { house_->setWalls("Wooden walls"); }
21    void buildDoors() override { house_->setDoors("Wooden doors"); }
22    void buildWindows() override { house_->setWindows("Plastic windows"); }
23    House* getHouse() override { return house_; }
24
25private:
26    House* house_;
27};

Step 4: Implement the Director

The Director class is responsible for managing the construction process. It uses a builder to construct the product.

 1class HouseDirector {
 2public:
 3    void setBuilder(HouseBuilder* builder) { builder_ = builder; }
 4    House* constructHouse() {
 5        builder_->buildWalls();
 6        builder_->buildDoors();
 7        builder_->buildWindows();
 8        return builder_->getHouse();
 9    }
10
11private:
12    HouseBuilder* builder_;
13};

Step 5: Client Code

Finally, the client code demonstrates how to use the Builder Pattern to construct different types of houses.

 1int main() {
 2    HouseDirector director;
 3
 4    StoneHouseBuilder stoneBuilder;
 5    director.setBuilder(&stoneBuilder);
 6    House* stoneHouse = director.constructHouse();
 7    stoneHouse->show();
 8
 9    WoodenHouseBuilder woodenBuilder;
10    director.setBuilder(&woodenBuilder);
11    House* woodenHouse = director.constructHouse();
12    woodenHouse->show();
13
14    delete stoneHouse;
15    delete woodenHouse;
16
17    return 0;
18}

Fluent Interface Design

The Builder Pattern can be enhanced with a fluent interface design, which allows method chaining to improve readability and usability. In C++, this can be achieved by returning a reference to the builder object from each method.

Example of Fluent Interface

Let’s modify our HouseBuilder to support a fluent interface.

 1class FluentHouseBuilder {
 2public:
 3    FluentHouseBuilder& buildWalls(const std::string& walls) {
 4        house_.setWalls(walls);
 5        return *this;
 6    }
 7
 8    FluentHouseBuilder& buildDoors(const std::string& doors) {
 9        house_.setDoors(doors);
10        return *this;
11    }
12
13    FluentHouseBuilder& buildWindows(const std::string& windows) {
14        house_.setWindows(windows);
15        return *this;
16    }
17
18    House getHouse() const { return house_; }
19
20private:
21    House house_;
22};

Using the Fluent Interface

The client code can now use the fluent interface to construct a house in a more readable manner.

 1int main() {
 2    FluentHouseBuilder builder;
 3    House house = builder.buildWalls("Brick walls")
 4                        .buildDoors("Metal doors")
 5                        .buildWindows("Double-glazed windows")
 6                        .getHouse();
 7    house.show();
 8
 9    return 0;
10}

Using Director Classes

The Director class plays a crucial role in the Builder Pattern by encapsulating the construction process. It ensures that the steps are executed in the correct order, which is particularly important for complex objects.

Benefits of Using Director Classes

• Separation of Concerns: The Director separates the construction logic from the representation of the product.
• Reusability: The same Director can be used with different builders to create various representations of the product.
• Flexibility: Changes to the construction process can be made in the Director without affecting the builders.

Design Considerations

When implementing the Builder Pattern, consider the following:

• Complexity vs. Simplicity: Use the Builder Pattern when the construction process is complex. For simple objects, a straightforward constructor may suffice.
• Memory Management: Ensure proper memory management, especially if dynamic memory allocation is involved.
• Thread Safety: If the construction process is used in a multithreaded environment, ensure that it is thread-safe.

Differences and Similarities

The Builder Pattern is often compared to the Factory Pattern. While both are creational patterns, they serve different purposes:

• Builder Pattern: Focuses on constructing a complex object step by step.
• Factory Pattern: Focuses on creating an object in a single step.

Visualizing the Builder Pattern

To better understand the Builder Pattern, let’s visualize its structure using a class diagram.

    classDiagram
	    class House {
	        -string walls
	        -string doors
	        -string windows
	        +setWalls(string)
	        +setDoors(string)
	        +setWindows(string)
	        +show()
	    }
	
	    class HouseBuilder {
	        +buildWalls()
	        +buildDoors()
	        +buildWindows()
	        +getHouse() House
	    }
	
	    class StoneHouseBuilder {
	        +buildWalls()
	        +buildDoors()
	        +buildWindows()
	        +getHouse() House
	    }
	
	    class WoodenHouseBuilder {
	        +buildWalls()
	        +buildDoors()
	        +buildWindows()
	        +getHouse() House
	    }
	
	    class HouseDirector {
	        +setBuilder(HouseBuilder)
	        +constructHouse() House
	    }
	
	    HouseBuilder <|-- StoneHouseBuilder
	    HouseBuilder <|-- WoodenHouseBuilder
	    HouseDirector --> HouseBuilder
	    HouseDirector --> House

Try It Yourself

To deepen your understanding of the Builder Pattern, try modifying the code examples:

• Add a new component to the House class, such as a roof, and update the builders accordingly.
• Implement a new ConcreteBuilder for a different type of house, such as a glass house.
• Experiment with the fluent interface by chaining additional methods.

Knowledge Check

Before we conclude, let’s reinforce what we’ve learned:

• What is the primary intent of the Builder Pattern?
• How does a Director class contribute to the Builder Pattern?
• What are the benefits of using a fluent interface?

Embrace the Journey

Remember, mastering design patterns is a journey. As you continue to explore and apply these patterns, you’ll enhance your ability to create robust and maintainable software. Keep experimenting, stay curious, and enjoy the process!

Quiz Time!