建造者（Builder）模式

建造者模式可以将一个产品的内部表象与产品的生成过程分割开来，从而可以使一个建造过程生成具有不同的内部表象的产品对象。

对象性质的建造

有些情况下，一个对象会有一些重要的性质，在它们没有恰当的值之前，对象不能作为一个完整的产品使用。比如，一个电子邮件有发件人地址、收件人地址、主题、内容、附录等部分，而在最起码的收件人地址未被赋值之前，这个电子邮件不能发出。

有些情况下，一个对象的一些性质必须按照某个顺序赋值才有意义。在某个性质没有赋值之前，另一个性质则无法赋值。这些情况使得性质本身的建造涉及到复杂的商业逻辑。

这时候，此对象相当于一个有待建造的产品，而对象的这些性质相当于产品的零件，建造产品的过程就是组合零件的过程。由于组合零件的过程很复杂，因此，这些"零件"的组合过程往往被"外部化"到一个称作建造者的对象里，建造者返还给客户端的是一个全部零件都建造完毕的产品对象。

Builder模式的结构：

①建造者（Builder）角色：给出一个抽象接口，以规范产品对象的各个组成成分的建造。一般而言，此接口独立于应用程序的商业逻辑。模式中直接创建产品对象的是具体建造者（ConcreteBuilder）角色。具体建造者类必须实现这个接口所要求的方法：一个是建造方法，另一个是结果返还方法。

②具体建造者（Concrete Builder）角色：担任这个角色的是于应用程序紧密相关的类，它们在应用程序调用下创建产品实例。这个角色主要完成的任务包括：

③实现Builder角色提供的接口，一步一步完成创建产品实例的过程。

在建造过程完成后，提供产品的实例。

指导者（Director）角色：担任这个角色的类调用具体建造者角色以创建产品对象。导演者并没有产品类的具体知识，真正拥有产品类的具体知识的是具体建造者对象。

④产品（Product）角色：产品便是建造中的复杂对象。

指导者角色是于客户端打交道的角色。导演者角色将客户端创建产品的请求划分为对各个零件的建造请求，再将这些请求委派给具体建造者角色。具体建造者角色是做具体建造工作的，但却不为客户端所知。

程序举例：

该程序演示了Builder模式一步一步完成构件复杂产品的过程。用户可以控制生成过程以及生成不同对象。

《大话设计模式》举了一个很好的例子——建造小人，一共需建造6个部分，头部、身体、左右手、左右脚。

与工厂模式不同，建造者模式是在导向者的控制下一步一步构造产品的。建造小人就是在控制下一步步构造出来的。创建者模式可以能更精细的控制构建过程，从而能更精细的控制所得产品的内部结构。

我们要生成不同的小人

[cpp] view plain copy print ?

1. // 产品[product]角色  
2. class Person    // 待建造的l人  
3. {  
4. public :  
5.     void SetHead(std::string head)  
6.     {  
7.         this->m_head = head;  
8.     }  
9.   
10.     std::string GetHead( )  
11.     {  
12.         return this->m_head;  
13.     }  
14.   
15.     void SetBody(std::string body)  
16.     {  
17.         this->m_body = body;  
18.     }  
19.   
20.     std::string GetBody( )  
21.     {  
22.         return this->m_body;  
23.     }  
24.   
25.     void SetFoot(std::string foot)  
26.     {  
27.         this->m_foot = foot;  
28.     }  
29.   
30.     std::string GetFoot( )  
31.     {  
32.         return this->m_foot;  
33.     }  
34.   
35.     void ShowPerson( )         // 显示当前的人的信息  
36.     {  
37.         std::cout <<"This is a person has" <<std::endl;  
38.         std::cout <<"HEAD : "<<this->m_head <<", BODY : " <<this->m_body <<", FOOT : " <<this->m_foot <<std::endl;  
39.     }  
40.   
41. protected :  
42.     std::string m_head;     // 人的头  
43.     std::string m_body;     // 人的躯体  
44.     std::string m_foot;     // 人的脚  
45. };  

// 产品[product]角色
class Person    // 待建造的l人
{
public :
	void SetHead(std::string head)
	{
		this->m_head = head;
	}

	std::string GetHead( )
	{
		return this->m_head;
	}

	void SetBody(std::string body)
	{
		this->m_body = body;
	}

	std::string GetBody( )
	{
		return this->m_body;
	}

	void SetFoot(std::string foot)
	{
		this->m_foot = foot;
	}

	std::string GetFoot( )
	{
		return this->m_foot;
	}

	void ShowPerson( )         // 显示当前的人的信息
	{
		std::cout <<"This is a person has" <<std::endl;
		std::cout <<"HEAD : "<<this->m_head <<", BODY : " <<this->m_body <<", FOOT : " <<this->m_foot <<std::endl;
	}

protected :
    std::string m_head;     // 人的头
    std::string m_body;     // 人的躯体
    std::string m_foot;     // 人的脚
};

不同的小人由不同的建造工程师进行设计

[cpp] view plain copy print ?

1. // 建造者[build]角色  
2. class Builder    // 建造者的基类  
3. {  
4. public :  
5.     Builder()             // 无参数的构造函数  
6.     {  
7.         this->m_person = new Person( );  
8.     }  
9.   
10.     virtual ~Builder( )      // 析构函数  
11.     {  
12.         delete this->m_person;  
13.     }  
14.   
15.   
16.     Person*& GetPerson( )            // 获取建造者建造的人对象  
17.     {  
18.         return this->m_person;  
19.     }  
20.   
21.     virtual void BuildHead( ) = 0;          // 建造人的头  
22.   
23.     virtual void BuildBody( ) = 0;          // 建造人的躯体  
24.   
25.     virtual void BuildFoot( ) = 0;          // 建造人的脚  
26.   
27. protected :  
28.     Person *m_person;  
29. };  
30.   
31. // 胖子的实际建造者-=> 具体建造者[Concrete Builder]  
32. class FatBuilder : public Builder  
33. {  
34. public :  
35.     FatBuilder()             // 无参数的构造函数  
36.     :Builder( )  
37.     {  
38.        // this->m_person = new Person( );  
39.     }  
40.   
41.     virtual ~FatBuilder( )      // 析构函数  
42.     {  
43.     }  
44.   
45.     void BuildHead( )          // 建造人的头  
46.     {  
47.         this->m_person->SetHead("Fat Head");  
48.         std::cout <<"Build Fat head..." <<std::endl;  
49.     }  
50.   
51.     void BuildBody( )         // 建造人的躯体  
52.     {  
53.         this->m_person->SetBody("Fat Body");  
54.         std::cout <<"Build Fat body..." <<std::endl;  
55.     }  
56.   
57.     void BuildFoot( )          // 建造人的脚  
58.     {  
59.         this->m_person->SetFoot("Fat Foot");  
60.         std::cout <<"Build Fat foot..." <<std::endl;  
61.     }  
62.   
63. };  
64.   
65.   
66.   
67. // 瘦人的实际建造者-=>具体建造者[Concrete Builder]  
68. class ThinBuilder : public Builder  
69. {  
70. public :  
71.     ThinBuilder( )             // 无参数的构造函数  
72.     :Builder( )  
73.     {  
74.        // this->m_person = new Person( );  
75.     }  
76.   
77.     virtual ~ThinBuilder( )      // 析构函数  
78.     {  
79.     }  
80.       
81.     void BuildHead( )          // 建造人的头  
82.     {  
83.         this->m_person->SetHead("Thin Head");  
84.         std::cout <<"Build thin head..." <<std::endl;  
85.     }  
86.   
87.     void BuildBody( )         // 建造人的躯体  
88.     {  
89.         this->m_person->SetBody("Thin Body");  
90.         std::cout <<"Build thin body..." <<std::endl;  
91.     }  
92.   
93.     void BuildFoot( )          // 建造人的脚  
94.     {  
95.         this->m_person->SetFoot("Thin Foot");  
96.         std::cout <<"Build thin foot..." <<std::endl;  
97.     }  
98.   
99. };  

// 建造者[build]角色
class Builder    // 建造者的基类
{
public :
    Builder()             // 无参数的构造函数
    {
        this->m_person = new Person( );
    }

    virtual ~Builder( )      // 析构函数
    {
        delete this->m_person;
    }


    Person*& GetPerson( )            // 获取建造者建造的人对象
    {
        return this->m_person;
    }

    virtual void BuildHead( ) = 0;          // 建造人的头

    virtual void BuildBody( ) = 0;          // 建造人的躯体

    virtual void BuildFoot( ) = 0;          // 建造人的脚

protected :
    Person *m_person;
};

// 胖子的实际建造者-=> 具体建造者[Concrete Builder]
class FatBuilder : public Builder
{
public :
    FatBuilder()             // 无参数的构造函数
    :Builder( )
    {
       // this->m_person = new Person( );
    }

    virtual ~FatBuilder( )      // 析构函数
    {
    }

	void BuildHead( )          // 建造人的头
	{
		this->m_person->SetHead("Fat Head");
		std::cout <<"Build Fat head..." <<std::endl;
	}

	void BuildBody( )         // 建造人的躯体
	{
		this->m_person->SetBody("Fat Body");
		std::cout <<"Build Fat body..." <<std::endl;
	}

	void BuildFoot( )          // 建造人的脚
	{
		this->m_person->SetFoot("Fat Foot");
		std::cout <<"Build Fat foot..." <<std::endl;
	}

};



// 瘦人的实际建造者-=>具体建造者[Concrete Builder]
class ThinBuilder : public Builder
{
public :
    ThinBuilder( )             // 无参数的构造函数
    :Builder( )
    {
       // this->m_person = new Person( );
    }

    virtual ~ThinBuilder( )      // 析构函数
    {
    }
	
	void BuildHead( )          // 建造人的头
	{
		this->m_person->SetHead("Thin Head");
		std::cout <<"Build thin head..." <<std::endl;
	}

	void BuildBody( )         // 建造人的躯体
	{
		this->m_person->SetBody("Thin Body");
		std::cout <<"Build thin body..." <<std::endl;
	}

	void BuildFoot( )          // 建造人的脚
	{
		this->m_person->SetFoot("Thin Foot");
		std::cout <<"Build thin foot..." <<std::endl;
	}

};

我们有一个向导来控制小人的创建，只要告诉它我们需要什么样的小人，向导会自动为我们设计

[cpp] view plain copy print ?

1. // 向导  
2. class Director  
3. {  
4. public :  
5.     Director(Builder *builder)          // 向导类构造函数  
6.     {  
7.         this->m_builder = builder;  
8.     }  
9.   
10.     void CreatePerson( )  
11.     {     
12.         this->m_builder->BuildHead( );      // 利用建造者建造人的头  
13.         this->m_builder->BuildBody( );      // 利用建造者建造人的躯体  
14.         this->m_builder->BuildFoot( );      // 利用建造者建造人的脚  
15.     }  
16.   
17. protected:  
18.     Builder *m_builder;         //  
19. };  

// 向导
class Director
{
public :
    Director(Builder *builder)          // 向导类构造函数
    {
        this->m_builder = builder;
    }

	void CreatePerson( )
	{	
		this->m_builder->BuildHead( );      // 利用建造者建造人的头
		this->m_builder->BuildBody( );      // 利用建造者建造人的躯体
		this->m_builder->BuildFoot( );      // 利用建造者建造人的脚
	}

protected:
    Builder *m_builder;         //
};

下面看看客户端调用的代码

[cpp] view plain copy print ?

1. int main()  
2. {  
3.     std::cout <<"Start create thin person..." <<std::endl;  
4.     ThinBuilder thinBuilder;  
5.     Director thinDirector(&thinBuilder);  
6.     thinDirector.CreatePerson( );  
7.     Person *thinPerson = thinBuilder.GetPerson( );  
8.     thinPerson->ShowPerson( );  
9.     std::cout <<std::endl;  
10.   
11.   
12.     std::cout <<"Start create fat person..." <<std::endl;  
13.     FatBuilder fatBuilder;  
14.     Director fatDirector(&fatBuilder);  
15.     fatDirector.CreatePerson( );  
16.     Person *fatPerson = fatBuilder.GetPerson( );  
17.     fatPerson->ShowPerson( );  
18.     std::cout <<std::endl;  
19.   
20.   
21.     return 0;  
22. }  

转载：http://blog.csdn.net/gatieme/article/details/21512591