设计模式-建造者模式(Builder)

应用场景：

1、相同的方法，不同的执行顺序，产生不同的事件结果时，可以采用建造者模式。

2、多个部件或零件,都可以装配到一个对象中，但是产生的运行结果又不相同时，则可以使用该模式。

3、产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使用建造者模式是非常合适。

4、在对象创建过程中会使用到系统中的一些其它对象，这些对象在产品对象的创建过程中不易得到时，也可以采用建造者模式封装该对象的创建过程。该种场景，只能是一个补偿方法，因为一个对象不容易获得，而在设计阶段竟然没有发觉，而要通过创建者模式柔化创建过程，本身已经违反设计最初目标。

优点：

1、封装性：

使用建造者模式可以使客户端不必知道产品内部组成的细节，如例子中我们就不需要关心每一个具体的模型内部是如何实现的。

2、建造者独立，容易扩展

3、便于控制细节风险

  由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。

 

缺点：

 创建者模式比较符合产品差别不大的对象的创建，如果差别很大，就会导致非常多的具体的创建者，这时候最好结合工厂方法模式。

简单实现：

#include <string>

#include <iostream>

#include <vector>

using namespace std;

//最终的产品类

class Product

{

private:

vector<string> m_product;

public:

void Add(string strtemp)

{

m_product.push_back(strtemp);

}

void Show()

{

vector<string>::iterator p=m_product.begin();

while (p!=m_product.end())

{

cout<<*p<<endl;

p++;

}

}

};

//建造者基类

class Builder

{

public:

virtual void BuilderA()=0;

virtual void BuilderB()=0;

virtual Product* GetResult()=0;

};

//第一种建造方式

class ConcreteBuilder1 : public Builder

{

private:

Product* m_product;

public:

ConcreteBuilder1()

{

m_product=new Product();

}

virtual void BuilderA()

{

m_product->Add("one");

}

virtual void BuilderB()

{

m_product->Add("two");

}

virtual Product* GetResult()

{

return m_product;

}

};

//第二种建造方式

class ConcreteBuilder2 : public Builder

{

private:

Product * m_product;

public:

ConcreteBuilder2()

{

m_product=new Product();

}

virtual void BuilderA()

{

m_product->Add("A")

}

virtual void BuilderB()

{

m_product->Add("B");

}

virtual Product* GetResult()

{

return m_product;

}

};

//指挥者类

class Direct

{

public:

void Construct(Builder* temp)

{

Temp->BuilderA();

Temp->BuilderB();

}

};

//客户端

int main()

{

Direct *p=new Direct();

Builder* b1=new ConcreteBuilder1();

Builder* b2=new ConcreteBuilder2();

p->Construct(b1); //调用第一种方式

Product* pb1=b1->GetResult();

pb1->Show();

p->Construct(b2); //调用第二种方式

Product * pb2=b2->GetResult();

pb2->Show();

return 0;

}

例二（其实这个例子应该放在前面讲的）：

#include <string>

#include <iostream>

#include <vector>

using namespace std;

class Person

{

public:

virtual void CreateHead()=0;

virtual void CreateHand()=0;

virtual void CreateBody()=0;

virtual void CreateFoot()=0;

};

class ThinPerson : public Person

{

public:

virtual void CreateHead()

{

cout<<"thin head"<<endl;

}

virtual void CreateHand()

{

cout<<"thin hand"<<endl;

}

virtual void CreateBody()

{

cout<<"thin body"<<endl;

}

virtual void CreateFoot()

{

cout<<"thin foot"<<endl;

}

};

class ThickPerson : public Person

{

public:

virtual void CreateHead()

{

cout<<"ThickPerson head"<<endl;

}

virtual void CreateHand()

{

cout<<"ThickPerson hand"<<endl;

}

virtual void CreateBody()

{

cout<<"ThickPerson body"<<endl;

}

virtual void CreateFoot()

{

cout<<"ThickPerson foot"<<endl;

}

};

//指挥者类

class Direct

{

private:

Person* p;

public:

Direct(Person* temp) { p = temp;}

void Create()

{

p->CreateHead();

p->CreateBody();

p->CreateHand();

p->CreateFoot();

}

};

//客户端代码：

int main()

{

Person *p=new ThickPerson();

Direct *d= new Direct(p);

d->Create();

delete d;

delete p;

return 0;

}