设计模式--建造者模式（C++实现）

/*建造者模式
1.客户类直接建造房子
2.工程队通过，将房子不同的建造部分进行封装，然后重写。实现解耦合
3.通过创建一个设计师，在设计师的建造函数中实现（对象不同部分的创建功能（是因为传进来了指向子类的基类指针））
然后建造函数通过此指针，去调用派生类的函数进行创建工作
//设计师指挥工程队干活  在设计师的建造函数内部实现了，对象不同部分的创建工作，将对象的创建与实现解耦合
//在建造的过程中，将底层的函数进行封装，最终调用的还是客户进行封装时调用的函数，只是将其往上层进行了封装

创建的是一个复合对象：被创建的对象为一个具有复合属性的复合对象- 关注对象创建的各部分的创建过程：
/****************************************************************************************
不同的工厂（这里指builder生成器）对产品属性有不同的创建方法，可以创建全部，也可以创建部分
*****************************************************************************************
*/
#include <iostream>
using namespace std;
#include "string"
class House
{//设计一个房子类，可以给其赋值，也可以返回此类对象的属性
public:
void setFloor(string floor)
{this->m_floor = floor;}
void setWall(string wall)
{ this->m_wall = wall;}
void setDoor(string door)
{ this->m_door = door;}


string getFloor()
{ return m_floor;}
string setWall()
{ return  m_wall;}
string setDoor()
{ return m_door;}
private:
string m_floor;
string m_wall;
string m_door;
};
class Builder
{//建筑队类，建筑队实现建筑工作
public:
virtual void makeFloor() = 0;
virtual void makeWall() = 0;
virtual void makeDoor() = 0;
virtual House *GetHouse() = 0;
};//类中包含其它类的指针，实现绑架效果
class FlatBuild : public Builder//公寓
{//初始化一个房子对象，然后实现建造功能
public://在建造的过程中先把对象创建出来，然后在对其属性进行赋值
FlatBuild()
{ pHouse = new House;}
virtual void makeFloor()
{ pHouse->setFloor("flat Door");}
virtual void makeWall()
{ pHouse->setWall("flat Wall");}
virtual void makeDoor()
{ pHouse->setDoor("flat Door");}
virtual House *GetHouse()
{ return pHouse;}
private:
House *pHouse;
};
class VillaBuild : public Builder//别墅
{//初始化一个房子对象，然后实现建造功能
public:
VillaBuild()
{ pHouse = new House;}
virtual void makeFloor()
{ pHouse->setFloor("villa floor");}
virtual void makeWall()
{ pHouse->setWall("villa Wall");}
virtual void makeDoor()
{ pHouse->setDoor("villa Door");}
virtual House *GetHouse()
{ return pHouse;}
private:
House *pHouse;
};
class Director
{//class这个比对象绑架有高级点了
public://这里使用的对象注入的功能，将你建造的对象，通过指针传递过来，然后使用指针进行操作
void Construct(Builder *builder)
{
builder->makeFloor();
builder->makeWall();
builder->makeDoor();
}
};
void main()
{
//客户直接造房子         
House *pHose = new House;
pHose->setDoor("wbm门");
pHose->setFloor("wbmFloor");
pHose->setWall("wbmWall");
delete pHose;
//工程队直接造房子
/*Builder *builder = new FlatBuild;
builder->makeFloor();
builder->makeWall();
builder->makeDoor();
*/
//指挥者（设计师）指挥 工程队 和 建房子
Director *director = new Director;//创建一个设计师
//建公寓
Builder *builder = new FlatBuild;//创建一个公寓对象，返回基类指针
director->Construct(builder); //设计师指挥工程队干活  在设计师的建造函数内部实现了，对象不同部分的创建工作，将对象的创建与实现解耦合
//在建造的过程中，将底层的函数进行封装，最终调用的还是客户进行封装时调用的函数，只是将其往上层进行了封装
House *house = builder->GetHouse();//创建完毕后返回此对象的指针，完成控制反转。
cout << house->getFloor() << endl;
delete house;
delete builder;
//建别墅
builder = new VillaBuild;
director->Construct(builder); 
house = builder->GetHouse();
cout << house->getFloor() << endl;
delete house;
delete builder;
delete director;
system("pause");
}

建造者模式：

一个类内部的不同部分的创建工作，使用更高层次的类，对不同的部分的创建再次进行封装（使用一个抽象类对创建功能提供接口：：然后想创建什么样的对象，在去重写不同的函数即可，）现在编写一个设计师类来完成这样的工作（就是在设计师的建造函数内部通过传递来的抽象类的指针，去调用不同的实现部分完成创建功能）

来源：传智博客---王保明