构建器模式-C++实现

构建器模式是一种创建型设计模式，主要用于构建需要多个步骤和复杂参数的对象。该模式可以把对象的构建过程和它的表示进行分离，使得同样的构建过程可以有不同的表示。

比如说我们要建造一座房子，这个房子的类型有很多种，比如石头房、茅草房，但是它们的构造过程是相同的，我们都需要构造一个天花板、一扇门、两扇窗户。

构建器分为四个角色：

• 产品：需要创建的复杂对象，该对象包含多个属性和部件。上述例子提到的“房子”。
• 抽象构建器：定义了创建产品的各个步骤以及组装产品的方法。上述例子提到的创建天花板、创建门、创建窗户。
• 具体构建器：实现了抽象构建器定义的方法。
• 指导者：负责调用具体构建器，按照一定的顺序执行构建步骤，创建产品。比如上述例子中我们先构建天花板、再构建门、最后构建窗户，这是创建一座房子需要的步骤。

构建器模式的主要思想是将构建过程拆分为多个步骤来创建一个复杂的对象，通过这种方式，可以灵活地组合步骤，以创建不同的产品。

举一个例子：

假设我们现在要创建一辆车，它有三个步骤：创建方向盘、创建车轮、创建刹车。三个步骤的顺序：1、构建方向盘 2、构建四个车轮 3、构建刹车。

// 产品 - 车
class Car
{
public:

	// 构建方向盘
	void CreateSteerWheel(const std::string& _brand)
	{
		std::cout << "构建方向盘: " << _brand << "品牌" << std::endl;

		steer_wheel_ = _brand;
	}

	// 构建车轮
	void CreateWheel(const std::string& _brand)
	{
		std::cout << "构建车轮: " << _brand << "品牌" << std::endl;

		wheel_.emplace_back(_brand);
	}

	// 构建刹车
	void CreateBrake(const std::string& _brand)
	{
		std::cout << "构建刹车: " << _brand << "品牌" << std::endl;

		brake_ = _brand;
	}

	// 开车
	void Drive()
	{
		std::cout << "启动" << std::endl;
	}

private:

	std::string steer_wheel_;
	std::vector<std::string> wheel_;
	std::string brake_;
};

// 抽象构建器
class CarBuilder
{
public:
	
	virtual ~CarBuilder() {}

	virtual void BuildSteerWheel() = 0;

	virtual void BuildWheel() = 0;

	virtual void BuildBrake() = 0;

	virtual std::shared_ptr<Car> GetResult() = 0;
};

// 具体构建器
class Benz
	: public CarBuilder
{
public:

	Benz()
	{
		car_ = std::make_shared<Car>();
	}

	virtual void BuildSteerWheel() override
	{
		car_->CreateSteerWheel("米其林");
	}

	virtual void BuildWheel() override
	{
		car_->CreateWheel("米其林");
	}

	virtual void BuildBrake() override
	{
		car_->CreateBrake("米其林");
	}

	virtual std::shared_ptr<Car> GetResult() override
	{
		if (car_)
			return car_;
	}

private:

	std::shared_ptr<Car> car_;
};

// 指导者
class CarDirector
{
public:

	std::shared_ptr<Car> Build(std::shared_ptr<CarBuilder> _car_build)
	{
		// 构建步骤：1、构建方向盘 2、构建四个车轮 3、构建刹车

		_car_build->BuildSteerWheel();

		for (int i = 0; i < 4; i++)
		{
			_car_build->BuildWheel();
		}

		_car_build->BuildBrake();

		return _car_build->GetResult();
	}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

测试：

void TestBuilder()
{
	// 指导者
	std::shared_ptr<CarDirector> director = std::make_shared<CarDirector>();

	// 构建器
	std::shared_ptr<CarBuilder> car_build = std::make_shared<Benz>();

	// 指导者去调用具体构建器
	std::shared_ptr<Car> car = director->Build(car_build);

	car->Drive();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

输出：

构建方向盘: 米其林品牌
构建车轮: 米其林品牌
构建车轮: 米其林品牌
构建车轮: 米其林品牌
构建车轮: 米其林品牌
构建刹车: 米其林品牌
启动
1
2
3
4
5
6
7

构建器模式遵循以下设计原则：

1、单一职责原则（SRP）：将对象的构建从对象本身分离出来，使得对象只需要关注自己的业务逻辑。具体来说，构建器把对象的构建单独放在了一个地方，对象可以专注于它自身的职责。

2、开闭原则（OCP）：构建器模式允许添加新的步骤来创建对象，而不需要改变现有的构建器和客户端代码。这样，我们可以方便地扩展构建逻辑而不用影响现有的代码。

3、里氏替换原则（LSP）：构建器模式中，构建器和具体的产品都是实现同一个接口或抽象类的子类。这保证了这些对象可以互相替换，而不影响系统的正常运行。

4、接口隔离原则（ISP）：构建器模式提供了一个定义通用构建步骤的接口，而具体步骤可以通过实现这个接口来进行扩展。这样，构建器的使用者只需要关注通用接口，而不需要了解具体步骤的实现细节，实现了隔离接口和实现的分离。

5、依赖倒置原则（DIP）：构建器模式中客户端只需要依赖于通用构建器接口和具体产品的抽象类或接口，而不需要依赖具体的构建器实现或产品类。这种方式可以解耦客户端和具体实现之间的关系。

构建器模式的优点：

• 将复杂对象的构建过程分解为多个简单步骤，易于理解和维护。
• 可以控制产品的构建过程，确保对象的一致性和完整性。
• 可以灵活地组合不同的构建步骤，创建不同的表示。
• 可以在构建过程中逐步创建对象，避免对象的不完整性。