建造者模式
代码仓库地址:建造者模式
Builder
模式也叫建造者模式或者生成器模式,是由GoF
提出的23种设计模式中的一种。Builder
模式是一种对象创建模式之一,用来隐藏复合对象的创建过程。他把复合对象的创建过程加以抽象,通过子类继承和重载的方式,动态地创建具有复合属性的对象。
对象的创建:Builder
模式是为了对象的创建而设计的模式-创建的是一个复合对象,被创建的对象为一个具有复合属性的复合对象,关注对象创建的各个部分的创建过程,不同工厂(Builder
)对产品属性有不同的创建方法。
Builder
:为创建产品各个部分,统一抽象接口ConcreteBuilder
: 具体的创建产品的各个部分,部分A,部分B,部分CDirector
: 构造一个使用Builder
接口的对象Product
:表示被构造的复杂对象
ConcreteBuilder
创建该产品的内部表示并定义它的装配过程,包含定义组成部分的类,包含将这些部件装配成最终产品的接口。
适用情况:
一个对象的构建比较复杂,将一个对象的构建和对象的表示进行分离。
说白了:建造者模式,其实就是相当于一个设计师,指挥建造师造房子,建造师可能是不同的,因为每个建造师建造水平和会造的房子都是不一样的。
创建者模式和工厂模式的对比
Factory
模式中:
- 有一个抽象的工厂
- 实现一个具体的工厂 - 汽车工厂
- 工厂生产的汽车A,得到汽车产品A
- 工厂生产汽车B,得到汽车产品B
实现了购买者和生产线的隔离,强调的是结果
Builder
模式
- 引擎工厂生产引擎产品,得到汽车的部件A
- 轮胎工厂生产轮子产品,得到汽车部件B
- 底盘工厂生产车身产品,得到汽车部件C
- 将这些部件放到一起,形成刚好能够组装成一辆汽车的整体
这样做,目的是为了实现复杂对象生产线和其部件的解耦。强调的是过程
两者的区别在于以下几种情况:
工厂模式不考虑对象的组装过程,而直接生成一个我想要的对象。
Builder
模式先一个个的创建对象的每一个部件,再统一组装成一个对象
工厂模式所解决的问题是,工厂生产产品
而Builder
模式解决的是工厂控制产品 生成器组装各个部件的过程,然后从产品生成器中得到产品。
前期问题的抛出-需要建造者模式的原因
#include <iostream>
#include <string>
using namespace std;
class House
{
public:
void setDoor(string door)
{
this->m_door = door;
}
void setWall(string wall)
{
this->m_wall = wall;
}
void setWindow(string window)
{
this->m_window = window;
}
string getDoor(void)
{
cout << m_door << endl;
return m_door;
}
string getWall(void)
{
cout << m_wall << endl;
return m_wall;
}
string getWindow(void)
{
cout << m_window << endl;;
return m_window;
}
private:
string m_door;
string m_wall;
string m_window;
};
class Builder
{
public:
Builder(void)
{
m_house = new House;
}
~Builder(void)
{
delete m_house;
}
void MakeBuilder(void)
{
BuildDoor(m_house);
BuildWall(m_house);
BuildWindow(m_house);
}
void BuildDoor(House *h)
{
h->setDoor("door");
}
void BuildWall(House *h)
{
h->setWall("wall");
}
void BuildWindow(House *h)
{
h->setWindow("window");
}
House *GetHouse(void)
{
return m_house;
}
private:
House *m_house;
};
int main(int argc, char const *argv[])
{
// 不需要建造者,客户直接造房子
// 门窗 墙体玻璃等都需要用户管理
House *house = new House;
house->setDoor("user door");
house->setWall("user Wall");
house->setWindow("big window");
house->getDoor();
house->getWall();
house->getWindow();
delete house;
// 华丽的分割线
cout << "=========================" << endl;
// 请工程队 建造房子
// 将建造过程交给工程队, 是不是还可以请个指挥建造的? 这样客户就能完全解放出来了
Builder *builder = new Builder;
builder->MakeBuilder();
house = builder->GetHouse();
house->getDoor();
house->getWall();
house->getWindow();
delete builder;
cout << "builder pattern." << endl;
return 0;
}
两者,虽然都建造好了房子,但是建筑队参加之后,客户就不需要参与房子的建造的每个过程了,将建造过程与使用者之间进行分离,这就是建造者模式想要达到的效果
andrew@andrew-G3-3590:/work/linux-sys/DesignPatterns/cpp/build$ ./builder_pattern_question
user door
use Wall
big window
=========================
door
wall
window
builder pattern.
那除了这样其实可以再请一个指挥者过来,因为实际中会有不同的建造者参与竞争,每个建造者精通的地方都是不一样的,指挥者参与之后,用户只需要把自己的需求告知指挥者就行。
- 建造者模式,就是通过虚工程对基类,实现通过指挥者,指挥不同的建筑队建设不同的房子
#include <iostream>
#include <string>
using namespace std;
// 建造者模式,就是通过虚工程对基类,实现
// 通过指挥者,指挥不同的建筑队建设不同的房子
class House
{
public:
void setDoor(string door)
{
this->m_door = door;
}
void setWall(string wall)
{
this->m_wall = wall;
}
void setWindow(string window)
{
this->m_window = window;
}
string getDoor(void)
{
cout << m_door << endl;
return m_door;
}
string getWall(void)
{
cout << m_wall << endl;
return m_wall;
}
string getWindow(void)
{
cout << m_window << endl;;
return m_window;
}
private:
string m_door;
string m_wall;
string m_window;
};
class Builder
{
public:
virtual void BuildWall(void) = 0;
virtual void BuildDoor(void) = 0;
virtual void BuildWindow(void) = 0;
virtual House* GetHouse(void) = 0;
public:
virtual ~Builder(void)
{
}
};
//公寓建筑工程队
class FlatBuilder : public Builder
{
public:
FlatBuilder()
{
m_house = new House;
}
virtual void BuildWall(void)
{
m_house->setWall("flat wall");
}
virtual void BuildDoor(void)
{
m_house->setDoor("flat door");
}
virtual void BuildWindow(void)
{
m_house->setWindow("flat window");
}
virtual House* GetHouse(void)
{
return m_house;
}
private:
House *m_house;
};
// 别墅工程队
class VillaBuilder : public Builder
{
public:
VillaBuilder(void)
{
m_house = new House;
}
virtual void BuildWall(void)
{
m_house->setWall("villa wall");
}
virtual void BuildDoor(void)
{
m_house->setDoor("villa door");
}
virtual void BuildWindow(void)
{
m_house->setWindow("villa window");
}
virtual House* GetHouse(void)
{
return m_house;
}
private:
House *m_house;
};
// 设计师 指挥者,负责建造的逻辑
// 建筑队,干具体的活
class Director
{
public:
Director(Builder *builder)
{
m_build = builder;
}
void Construct(void)
{
m_build->BuildWall();
m_build->BuildWindow();
m_build->BuildDoor();
}
private:
Builder * m_build;
};
int main(int argc, char const *argv[])
{
House *house = NULL;
Builder *builder = NULL;
Director *director = NULL;
cout << "villa build" << endl;
// 请一个建造别墅的工程队,建造一个别墅
builder = new VillaBuilder;
// 设计师 指挥工程队进行建造
director = new Director(builder);
// 指挥干活
director->Construct();
// 建好 交工
house = builder->GetHouse();
// 客户验房
house->getWindow();
house->getDoor();
house->getWall();
delete house;
delete builder;
cout << "flat build" << endl;
builder = new FlatBuilder;
director = new Director(builder);
director->Construct();
house = builder->GetHouse();
house->getDoor();
house->getWall();
house->getWindow();
delete house;
delete builder;
delete director;
cout << "builder pattern." << endl;
return 0;
}