23种设计模式（C++）之建造者模式

23种设计模式（C++）之建造者模式

概念

建造者模式（Builder），是一种创建型模式中的对象模式。我们先看下《设计模式-可复用面向对象软件的基础》一书对其描述。

意图

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

适用性

• 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
• 当构造过程必须允许被构造的对象有不同的表示时。

参与者

• Builder (不同类型的建造者)
  • 为待创建的Product对象的各个部件指定抽象接口。
• ConcreteBuilder (不同类型产品的建造者)
  • 实现Builder的接口以构造Product的各个部件。
  • 定义并明确它所创建的表示。
  • 提供一个检索产品的接口（即get接口）
• Director (指导创建过程的人)
  • 构造一个使用Builder接口的对象。
• Product (目标产品)
  • 表示被构造的复杂对象。
  • 包含定义各个组成部件的类，包括将这些部件装配成最终产品的接口。

通俗理解

以汽车为例，有一家生产电动汽车和油动汽车的汽车公司。一个客户跟汽车公司说需要一辆电动汽车，汽车公司安排制造电动汽车的工厂主管负责生产和装配的调度，主管根据汽车的装配流程，先让电动汽车车间加工齿轮，再让车间加工车身，加工完装配成车后运出给到客户。
此例中，电动汽车即为目标产品；电动汽车工厂主管即为Director；电动汽车车间即为ConcreteBuilder。

实例

还是以汽车为例，用C++实现上述的例子。

创建汽车的组件1类——齿轮

class Gear 
{
private: 
	string gearType;
public:
	Gear(){}
	Gear(string gearType) 
	{
		this->gearType = gearType;
	}
	string getGearType() 
	{
		return this->gearType;
	}
};

创建汽车的组件2类——车身

class Bodywork
{
private:
	string bodyworkType;
public:
	Bodywork() {}
	Bodywork(string bodyworkType)
	{
		this->bodyworkType = bodyworkType;
	}
	string getBodyworkType()
	{
		return this->bodyworkType;
	}
};

创建汽车类：

//Car
class Car
{
private:
	Gear gear;
	Bodywork *bodywork;
public:
	Car(){}
	void produceGear(Gear newgear)
	{
			this->gear = newgear;
		
	}
	Gear getGear()
	{
		return this->gear;
	}
	void produceBodywork(Bodywork *newbodywork)
	{
		if (newbodywork == nullptr) {
			cout << "there is a null ptr" << endl;
		}
		else {
			this->bodywork = newbodywork;
		}
		
	}
	Bodywork *getBodywork()
	{
		return this->bodywork;
	}
};

创建汽车建造者抽象类

//Builder, an abstract class
class AbstractBuilder
{
protected: //Subclass cannot call if private
	Car *car;
public: 
	virtual void buildGear() = 0;
	virtual void buildBodywork() = 0;
	virtual Car *getCar() = 0;
};

创建电动汽车建造者具体类

//Electric car builder
class ElectricCarBuilder : public AbstractBuilder
{
public:
	ElectricCarBuilder() 
	{
		this->car = new Car();
	};
	void buildGear()
	{
		//Gear gear = new Gear("electric");
		Gear gear("electric");
		this->car->produceGear(gear); 
	}
	void buildBodywork()
	{
		Bodywork *bodywork = new Bodywork("electric");
		this->car->produceBodywork(bodywork);
	}
	Car *getCar()
	{
		return this->car;
	}
};

创建油动汽车建造者具体类

//Oil car builder
class OilCarBuilder :public AbstractBuilder
{
public:
	OilCarBuilder()
	{
		this->car = new Car();
	};
	void buildGear()
	{
		Gear gear("oil");
		this->car->produceGear(gear);
	}
	void buildBodywork()
	{
		Bodywork *bodywork = new Bodywork("oil");
		this->car->produceBodywork(bodywork);
	}
	Car *getCar()
	{
		return this->car;
	}
};

创建指导员具体类

//Director
class Director 
{
private:
	AbstractBuilder *abstractBuilder;
public:
	Director(AbstractBuilder *targetBuilder)
	{
		this->abstractBuilder = targetBuilder;
	}
	Car* constructIt()
	{
		this->abstractBuilder->buildGear();
		this->abstractBuilder->buildBodywork();
		return this->abstractBuilder->getCar();
	}
};

客户端：

int main()
{
	AbstractBuilder *electricCarBuilder = new ElectricCarBuilder();
	Director electricCarDirector(electricCarBuilder);
	//Director *director = new Director(electricCarBuilder);
	Car *myElectricCar = electricCarDirector.constructIt();
	cout << "Gear: " << myElectricCar->getGear().getGearType() << "; Bodywork: " << myElectricCar->getBodywork()->getBodyworkType() << endl;

	AbstractBuilder *oilCarBuilder = new OilCarBuilder();
	Director oilCarDirector(oilCarBuilder);
	Car *myOilCar = oilCarDirector.constructIt();
	cout << "Gear: " << myOilCar->getGear().getGearType() << "; Bodywork: " << myOilCar->getBodywork()->getBodyworkType() << endl;
}

Result:

Gear: electric; Bodywork: electric
Gear: oil; Bodywork: oil

本文代码已调试通过编译运行，如要使用，自行添加头文件即可

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

由于本人初学设计模式，如有不足，欢迎指正，万分感谢。