Design patterns part 2 creative design patterns chapter 4 builder patterns (A: C++ implementation)

The Builder Pattern uses multiple simple objects to build a complex object step by step. This type of design pattern is the creation pattern, which provides the best way to create objects.

A Builder class constructs the final object step by step. The Builder class is independent of other objects.

, for example, a computer is made up of OPU, motherboard, memory, hard disk, video card, chassis, monitor, keyboard, mouse and other components are assembled, the buyer is not possible to assemble a computer, but computer configuration requirements told computer sales company, computer sales company to arrange technicians to assemble the computer, and then to the buyer to buy the computer.

There are many such examples in life. For example, different characters in the game are different in gender, personality, ability, face shape, body shape, clothing, hair style and other characteristics. There are also a variety of steering wheel, engine, frame, tire and other parts in the car; The sender, recipient, subject, content, attachment and other contents of each email are also different.

All of these products are made up of multiple parts that can be selected flexibly, but the steps to create them are pretty much the same. The creation of such products cannot be described by the factory pattern described earlier, and only the Builder pattern can describe the creation of such products well.

2.1 Modal Motivation

Whether in the real world or in software systems, there are complex objects that have multiple components, such as cars, which include wheels, steering wheels, transmitters, and other components. For most users, the assembling of the parts of a don’t need to know these details, also almost don’t use a single component, but use, is a complete car, can pass the builder pattern to design and the description, the builder pattern can separate parts and the assembly process, step by step to create a complex object. Users only need to specify the type of a complex object to get it, without knowing the details of its construction.

In software development, there are also a large number of complex objects like cars that have a set of member attributes, some of which are reference type member objects. And in these complex objects, there may be some restrictions, such as some attributes are not assigned value complex objects can not be used as a complete product; Some attributes must be assigned in a certain order, one attribute may not be assigned before another, and so on.

A complex object is the equivalent of a car to be built, the properties of an object are the parts of the car, and the process of building a product is the process of assembling parts. Due to the process of composite parts is very complex, so the combination of these parts process is often called “externalizing” to a builder object, builders returned to the client object is a complete product is built, and the user does not need to care about this object contains attributes and their way of assembly, this is the motivation of the builders mode.

2.2 Definition and characteristics of the mode

2.3 Structure and implementation of the mode

Builder mode is composed of four elements: product, abstract Builder, concrete Builder and commander. Now we analyze its basic structure and implementation method.

2.3.1 Pattern structure

2.3.2 implementation of pattern (C++ implementation)

So how does the Builder pattern work? For example, different ConcreteBuilder classes can be implemented in different ways. In this way, the template method pattern (described in a later section) is applied similarly to the builder pattern. However, the focus of the Builder pattern is that different directors can be presented differently, while the focus of the template method pattern is the different implementation of each step in the algorithm. In addition, the relationships between their classes are different. The template approach is implemented by inheritance, while the builder pattern is implemented by composition. The template method pattern is mainly used to execute different algorithms, and the Builder pattern is mainly used to build objects. However, both modes can achieve many similar functions. That’s okay, there are multiple ways to implement the same functionality. It depends on demand. In addition, in the actual writing of the program, there is no need to stick to a certain design mode, as long as the relevant principles, so that the whole program is efficient, stable, easy to expand, easy to maintain. There are also differences in the scenarios used.

The code looks like this:

#include <iostream>
#include <vector>

using namespace std;
/ / product
class Product
{
public:
	void Add(string str)
	{
		m_vec.push_back(str);
	}
	void Show(a)
	{
		for (auto it = m_vec.cbegin(a); it ! = m_vec.cend(); it++)
		{
			cout << *it << endl;
		}
	}
private:
	vector<string> m_vec;
};

// Constructor class
class Builder
{
public:
	virtual void BuildPartA(a) = 0;
	virtual void BuildPartB(a) = 0;
	virtual void BuildPartC(a) = 0;
	virtual Product getResult(a) = 0;
};

class ConcreteBuilder_0 : public Builder
{
public:
	ConcreteBuilder_0() : m_p(nullptr)
	{
		m_p = new Product(a); }virtual ~ConcreteBuilder_0()
	{
		if (nullptr == m_p)
			delete m_p;
	}
	virtual void BuildPartA(a)
	{
		string str = "Builder_0 BuildPartA";
		m_p->Add(str);
	}
	virtual void BuildPartB(a)
	{
		string str = "Builder_0 BuildPartB";
		m_p->Add(str);
	}
	virtual void BuildPartC(a)
	{
		string str = "Builder_0 BuildPartC";
		m_p->Add(str);
	}
	Product getResult(a)
	{
		return *m_p;
	}
private:
	Product * m_p;
};

class ConcreteBuilder_1 : public Builder
{
public:
	ConcreteBuilder_1() : m_p(nullptr)
	{
		m_p = new Product(a); }virtual ~ConcreteBuilder_1()
	{
		if (nullptr == m_p)
			delete m_p;
	}
	virtual void BuildPartA(a)
	{
		string str = "Builder_1 BuildPartA";
		m_p->Add(str);
	}
	virtual void BuildPartB(a)
	{
		string str = "Builder_1 BuildPartB";
		m_p->Add(str);
	}
	virtual void BuildPartC(a)
	{
		string str = "Builder_1 BuildPartC";
		m_p->Add(str);
	}
	Product getResult(a)
	{
		return *m_p;
	}
private:
	Product * m_p;
};
// Commander class
class Director
{
public:
	// How is this implemented according to the requirements
	void build(Builder *p)
	{
		p->BuildPartA(a); p->BuildPartC(a); p->BuildPartB();
	}
};

int main(int argc, char *argv[])
{
    // Dynamic association, dynamic association
	// Builder mode
	Builder *builder= new ConcreteBuilder_0(a); Director * director =new Director(a); director->build(builder);
	builder->getResult().Show(a); builder =new ConcreteBuilder_1(a); director->build(builder);
	builder->getResult().Show(a);if(director ! =NULL)
    {
        delete director;
        director = NULL;
    }

    if(builder ! =NULL)
    {
        delete builder;
        builder= NULL;
    }
    return 0;
}
Copy the code

2.4 Application Scenarios of Mode

2.5 Schema extensions

Simplification of the Builder model:

Regardless of the abstract builder: You can omit the abstract builder if only one concrete builder is needed in the system. Forgetting the role of commander: When there is only one Builder, the role of commander can be omitted if the abstract Builder role has already been omitted, allowing the Builder role to play both the role of commander and Builder.

Builder pattern vs. Abstract Factory pattern:

In contrast to the Abstract factory model, the Builder model returns an assembled complete product, while the Abstract factory model returns a series of related products that sit in different product hierarchies, forming a product family.  in the abstract factory pattern, the client class instance chemical plant, and then call the factory method to obtain the required product object, in the builder pattern, the client can not directly call the builders of relevant methods, but by commanders class to guide how to generate object, including the object of assembly process and construction step, step by step, it focuses on the construction of a complex object, Returns a complete object. At the same time, the builder mode is a car assembly factory, which returns a complete car by assembling parts.

2.6 summarize