博客
关于我
强烈建议你试试无所不能的chatGPT,快点击我
C++设计模式12--建造者模式----创建复杂对象的工程师
阅读量:7105 次
发布时间:2019-06-28

本文共 6619 字,大约阅读时间需要 22 分钟。

建造者(Builder)模式

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

 

对象性质的建造

 

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

 

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

 

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

 

 

 

Builder模式的结构:

 

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

 

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

 

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

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

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

 

④产品(Product)角色:产品便是建造中的复杂对象。

 

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

 

 

程序举例:

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

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

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

我们要生成不同的小人

[cpp]
  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" <
m_head <<", BODY : " <
m_body <<", FOOT : " <
m_foot <

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

[cpp]
  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..." <
m_person->SetBody("Fat Body"); std::cout <<"Build Fat body..." <
m_person->SetFoot("Fat Foot"); std::cout <<"Build Fat foot..." <
具体建造者[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..." <
m_person->SetBody("Thin Body"); std::cout <<"Build thin body..." <
m_person->SetFoot("Thin Foot"); std::cout <<"Build thin foot..." <

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

[cpp]
  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]
  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

你可能感兴趣的文章
团队冲刺第四天
查看>>
简短描述操作系统的进化史
查看>>
SSH服务拒绝了密码
查看>>
前端之Sass/Scss实战笔记
查看>>
windows server 2008 下安装openmeetings 2.2.0
查看>>
我的友情链接
查看>>
怎么修改PDF文件内容呢?你知道这种方法吗?
查看>>
Linux中不可小瞧且习以为常的安装服务方式
查看>>
linux帐号管理常用命令
查看>>
oracle UGA分布示意图
查看>>
row_number() over()排序功能说明
查看>>
索尼手机梦想王者归来?
查看>>
07课前考试题详解
查看>>
谈谈对程序员的培养
查看>>
bzoj 1012: [JSOI2008]最大数maxnumber
查看>>
关于jquery跨域调用REST服务的问题
查看>>
Android图标尺寸的约定
查看>>
从HTTP 2.0想到的关于传输层协议的一些事
查看>>
业余码农南瓜的第一篇博客
查看>>
XenDesktop 屏幕保护程序无法生效的解决办法
查看>>