建房子要怎么建?
首先要有一个包工头,即指挥者。为什么要请个包工头呢,因为包工头知道建房子的流程:首先打地基、然后建墙体,然后封顶,最后是装修。
除此之外,包工头还能根据客户的需求来盖不同类型的房子,比如普通楼房和别墅。
当然,少不了一批帮包工头干活的人,即建造者Builder。
用代码描述:
1 #include <string> 2 #include <iostream> 3 #include <vector> 4 using namespace std; 5 6 // 建筑队,打地基、筑墙、盖顶、装修都会 7 class Builder 8 { 9 public: 10 virtual void DaDiJi ()=0; 11 virtual void ZhuQiang ()=0; 12 virtual void GaiDing ()=0; 13 virtual void ZhuangXiu ()=0; 14 }; 15 // 建楼房 16 Class LouFangBuilder : public Builder 17 { 18 public: 19 virtual void DaDiJi () 20 { 21 cout<<"楼房打地基"<<endl; 22 } 23 virtual void ZhuQiang () 24 { 25 cout<<"楼房筑墙"<<endl; 26 } 27 virtual void GaiDing () 28 { 29 cout<<"楼房盖顶"<<endl; 30 } 31 virtual void ZhuangXiu () 32 { 33 cout<<"楼房装修"<<endl; 34 } 35 }; 36 // 建别墅 37 Class BieShuBuilder : public Builder 38 { 39 public: 40 virtual void DaDiJi () 41 { 42 cout<<"别墅打地基"<<endl; 43 } 44 virtual void ZhuQiang () 45 { 46 cout<<"别墅筑墙"<<endl; 47 } 48 virtual void GaiDing () 49 { 50 cout<<"别墅盖顶"<<endl; 51 } 52 virtual void ZhuangXiu () 53 { 54 cout<<"别墅装修"<<endl; 55 } 56 }; 57 58 // 包工头 59 class Direct 60 { 61 private: 62 // 包工头私有一个建筑队,只有包工头可以指挥。 63 // 这个建筑队名称根据需求来定, 64 // 建楼房的时候叫楼房建筑队,建别墅的时候叫别墅建筑队 65 Builder* builder; 66 public: 67 // 包工头指挥建筑队建房:打地基、筑墙、盖顶、装修。 68 void Construct(Builder * builder) 69 { 70 builder->DaDiJi(); 71 builder->ZhuQiang(); 72 builder->GaiDing(); 73 builder->ZhuangXiu(); 74 } 75 }; 76 77 // 客户端 78 int main() 79 { 80 // 指定包工头 81 Direct *director = new Direct(); 82 // 建楼房还是别墅 83 Builder *b1 = new LouFangBuilder(); 84 Builder *b2 = new BieShuBuilder(); 85 // 包工头指挥楼房建筑队建造楼房 86 director->Construct(b1); 87 return 0; 88 }
后来,房主说房子建好后我要检查,地基、墙体、房顶、装饰都要看看。包工头说好吧,那我就把地基、墙体、房顶、装饰作为四个装配部件,每完成一个过程,”产品“就装配一个部件,并提供展示的功能。交付产品的时候我就可以把所有部件给你看。
1 #include <string> 2 #include <vector> 3 #include <iostream> 4 using namespace std; 5 6 // 说干就干,房子作为我们的产品 7 class Product 8 { 9 vector<string> parts; 10 public: 11 // 每完成一个部件,”产品“就添加一个部件 12 void Add(const string part) 13 { 14 parts.push_back(part); 15 } 16 // 展示产品的每一个部分 17 void Show()const 18 { 19 for(int i = 0 ; i < parts.size() ; i++) 20 { 21 cout<<parts[i]<<endl; 22 } 23 } 24 }; 25 26 // 建筑队,打地基、筑墙、盖顶、装修都会 27 class Builder 28 { 29 public: 30 virtual void DaDiJi ()=0; 31 virtual void ZhuQiang ()=0; 32 virtual void GaiDing ()=0; 33 virtual void ZhuangXiu ()=0; 34 virtual Product GetResult() = 0; 35 }; 36 // 建楼房 37 class LouFangBuilder : public Builder 38 { 39 private: 40 Product product; 41 public: 42 virtual void DaDiJi() 43 { 44 product.Add("楼房地基"); // 产品添加楼房地基部件 45 } 46 virtual void ZhuQiang() 47 { 48 product.Add("楼房墙体"); // 产品添加楼房墙体部件 49 } 50 virtual void GaiDing() 51 { 52 product.Add("楼房房顶"); // 产品添加楼房房顶部件 53 } 54 virtual void ZhuangXiu() 55 { 56 product.Add("楼房装饰"); // 产品添加楼房装饰部件 57 } 58 virtual Product GetResult() 59 { 60 return product; 61 } 62 }; 63 // 建别墅 64 class BieShuBuilder : public Builder 65 { 66 private: 67 Product product; 68 public: 69 virtual void DaDiJi() 70 { 71 product.Add("别墅地基"); // 产品添加别墅地基部件 72 } 73 virtual void ZhuQiang() 74 { 75 product.Add("别墅墙体"); // 产品添加别墅墙体部件 76 } 77 virtual void GaiDing() 78 { 79 product.Add("别墅房顶"); // 产品添加别墅房顶部件 80 } 81 virtual void ZhuangXiu() 82 { 83 product.Add("别墅装饰"); // 产品添加别墅装饰部件 84 } 85 virtual Product GetResult() 86 { 87 return product; 88 } 89 }; 90 91 // 包工头 92 class Direct 93 { 94 private: 95 // 包工头私有一个建筑队,只有包工头可以指挥。 96 // 这个建筑队名称根据需求来定, 97 // 建楼房的时候叫楼房建筑队,建别墅的时候叫别墅建筑队 98 Builder* builder; 99 public: 100 // 包工头指挥建筑队建房:打地基、筑墙、盖顶、装修。 101 void Construct(Builder * builder) 102 { 103 builder->DaDiJi(); 104 builder->ZhuQiang(); 105 builder->GaiDing(); 106 builder->ZhuangXiu(); 107 } 108 }; 109 110 int main() 111 { 112 // 指定包工头 113 Direct *director = new Direct(); 114 // 建楼房还是别墅 115 Builder *b1 = new LouFangBuilder(); 116 Builder *b2 = new BieShuBuilder(); 117 // 包工头指挥楼房建筑队建造楼房 118 director->Construct(b1); 119 120 // 楼房建好了,包工头说,这就是我们的产品 121 Product p1 = b1->GetResult(); 122 // 产品交付,包工头把地基、墙体、房顶、装饰每一个部分都展示给房主看。 123 p1.Show(); 124 return 0; 125 }
可以看到,不管加不加产品类,建房子的流程是不变的,即整个Direct类没做任何改变。这就引出了建造者模式的定义:将一个复杂对象的构造与它的表示分离,使同样的构建过程可以创建不同的表示。就如同样的Construct可以创建楼房也可以创建别墅。
建造者模式和工厂方法模式类似,我们将上面的第一个例子改造成工厂方法模式,看看他们的区别。
色 部分为工厂方法模式
色 部分为建造者模式。
1 #include <string> 2 #include <iostream> 3 #include <vector> 4 using namespace std; 5 // 建筑队 6 class CBuilder 7 { 8 public: 9 virtual void DaDiJi ()=0; 10 virtual void ZhuQiang ()=0; 11 virtual void GaiDing ()=0; 12 virtual void ZhuangXiu ()=0; 13 }; 14 // 建楼房 15 class LouFangBuilder : public CBuilder 16 { 17 public: 18 virtual void DaDiJi () 19 { 20 cout<<"楼房打地基"<<endl; 21 } 22 virtual void ZhuQiang () 23 { 24 cout<<"楼房筑墙"<<endl; 25 } 26 virtual void GaiDing () 27 { 28 cout<<"楼房盖顶"<<endl; 29 } 30 virtual void ZhuangXiu () 31 { 32 cout<<"楼房装修"<<endl; 33 } 34 }; 35 // 建别墅 36 class BieShuBuilder : public CBuilder 37 { 38 public: 39 virtual void DaDiJi () 40 { 41 cout<<"别墅打地基"<<endl; 42 } 43 virtual void ZhuQiang () 44 { 45 cout<<"别墅筑墙"<<endl; 46 } 47 virtual void GaiDing () 48 { 49 cout<<"别墅盖顶"<<endl; 50 } 51 virtual void ZhuangXiu () 52 { 53 cout<<"别墅装修"<<endl; 54 } 55 }; 56 57 //工厂模式 58 class CFactory 59 { 60 public: 61 virtual CBuilder* Construct() = 0; 62 }; 63 64 class LouFangFactory: public CFactory 65 { 66 CBuilder* Construct () 67 { 68 return new LouFangBuilder(); 69 } 70 }; 71 class BieShuFactory: public CFactory 72 { 73 CBuilder* Construct () 74 { 75 return new BieShuBuilder(); 76 } 77 }; 78 79 // 建造者模式 80 class Direct 81 { 82 private: 83 CBuilder* builder; 84 public: 85 void Construct(CBuilder* temp) 86 { 87 builder->DaDiJi(); 88 builder->ZhuQiang(); 89 builder->GaiDing(); 90 builder->ZhuangXiu(); 91 } 92 }; 93 94 int main() 95 { 96 // 工厂模式 97 CFactory* p = new LouFangFactory; 98 CBuilder* opr = p->Construct(); 99 opr->DaDiJi(); 100 opr->ZhuQiang(); 101 opr->GaiDing(); 102 opr->ZhuangXiu(); 103 104 // 建造者模式 105 Direct *director = new Direct(); 106 CBuilder *b1 = new LouFangBuilder(); 107 CBuilder *b2 = new BieShuBuilder(); 108 director->Construct(b1); 109 110 return 0; 111 }
也就是说,工厂方法模式能生成不同的产品,也能将具体产品再分解成一个个零件,但调用的时候只能一个零件一个零件的造。
而建造者模式把造零件的过程放到了一起,当生产一个产品时,是作为整个产品生产出来,不需要一个零件一个零件的装配。
不知道为什么总感觉建造者模式一点都不像创建型模式?
最后,贴一下建造者模式的角色:
1)builder:为创建一个产品对象的各个部件指定抽象接口。
2)ConcreteBuilder:实现Builder的接口以构造和装配该产品的各个部件,定义并明确它所创建的表示,并 提供一个检索产品的接口。
3)Director:构造一个使用Builder接口的对象。
4)Product:表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程,包含定义组成部件的类,包括将这些部件装配成最终产品的接口。
来源:http://www.cnblogs.com/SnailProgramer/p/4255682.html