标签：
在GOF的《设计模式 可复用面向对象软件的基础》中是这样说的：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
这句话，似懂非懂的。一个复杂对象的创建，其通常是由很多的子对象构成；如果一个对象能够直接就创建好了，那么也不会称之为复杂对象。由于项目中需求的变化，这个复杂对象的各个部分经常会发生剧烈的变化，但是，不管怎么变化，将它们组合在一起，组成一个复杂的对象的事实是不会变的。建造者模式就提供了一种“封装机制”来将各个对象的变化隔离开，最终，组合成复杂对象的过程是不会变的。
在《大话设计模式》一书中，例举了一个很好的例子————建造小人。建造一个小人，要分为六步：头部、身体、左手、右手、左脚和右脚。与抽象工厂模式不同的是，建造者模式是在Director的控制下一步一步的构造出来的，在建造的过程中，建造者模式可以进行更精细的控制。不管人的头部、身体、左手、右手、左脚或者右脚如何变化，但是最终还是由这几部分组合在一起形成一个人，虽然是同一个建造过程，但是这个人就会有不同的表示，比如，胖子，瘦子，个高的，个低的等等。
类图如下：
时序图如下：
/***************************************************** * \file BuilderPatternDemo.cpp * \date 2016/07/24 15:57 * \author ranjiewen * \contact: ranjiewen@outlook.com *****************************************************/ #include<iostream> using namespace std; typedef enum MANTYPETag { kFatMan, kThinMa, kNormal }MANTYPE; class Man{ public: void SetHead(MANTYPE type){ m_Type = type; } void SetBody(MANTYPE type){ m_Type = type; } void SetLeftHand(MANTYPE type){ m_Type = type; } void SetRightHand(MANTYPE type){ m_Type = type; } void SetLeftFoot(MANTYPE type){ m_Type = type; } void SetRightFoot(MANTYPE type){ m_Type = type; } void ShowMan() { switch (m_Type) { case kFatMan: cout << "I‘m a fat man!"; break; case kThinMa: cout << "I‘m a thin man!"; break; default: cout << "I‘m a normal man!"; break; } } private: MANTYPE m_Type; }; class Builder{ public: virtual void buildHead() = 0; virtual void buildBody() = 0; virtual void buildLeftHand() = 0; virtual void buildRightHand() = 0; virtual void buildLeftFoot() = 0; virtual void buildRightFoot() = 0; virtual Man* getMan() = 0; }; class FatBuilder :public Builder{ public: FatBuilder() { m_FatMan = new Man(); } void buildHead(){ m_FatMan->SetHead(kFatMan); } void buildBody(){ m_FatMan->SetBody(kFatMan); } void buildLeftHand(){ m_FatMan->SetLeftHand(kFatMan); } void buildRightHand(){ m_FatMan->SetRightHand(kFatMan); } void buildLeftFoot(){ m_FatMan->SetLeftFoot(kFatMan); } void buildRightFoot(){ m_FatMan->SetRightFoot(kFatMan); } Man* getMan(){ return m_FatMan; } private: Man* m_FatMan; }; class ThinBuilder :public Builder { private: Man* m_ThinMan; ThinBuilder(){ m_ThinMan = new Man(); } void buildHead(){ m_ThinMan->SetHead(kThinMa); } void buildBody(){ m_ThinMan->SetBody(kThinMa); } void buildLeftHand(){m_ThinMan->SetLeftHand(kThinMa); } void buildRightHand(){ m_ThinMan->SetRightHand(kThinMa); } void buildLeftFoot(){ m_ThinMan->SetLeftFoot(kThinMa); } void buildRightFoot(){ m_ThinMan->SetRightFoot(kThinMa); } Man* getMan(){ return m_ThinMan; } }; class Director{ private: Builder* m_Builder; public: Director(Builder *builder):m_Builder(builder){} void CreateMan(); }; void Director::CreateMan(){ m_Builder->buildHead(); m_Builder->buildBody(); m_Builder->buildLeftHand(); m_Builder->buildRightHand(); m_Builder->buildLeftFoot(); m_Builder->buildRightFoot(); } int main(){ Builder* builderObj = new FatBuilder(); Director directorObj(builderObj); directorObj.CreateMan(); Man* manObj = builderObj->getMan(); if (manObj!=nullptr) { manObj->ShowMan(); } delete manObj; manObj = nullptr; delete builderObj; builderObj = nullptr; return 0; }
上面这个例子比较杂，但是也是建造者模式的应用。下面这个例子是建造者最一般，最简单的实现方法：
#include <iostream> #include <vector> using namespace std; class Builder; // Product class Product { public: void AddPart(const char *info) { m_PartInfoVec.push_back(info); } void ShowProduct() { for (std::vector<const char *>::iterator item = m_PartInfoVec.begin(); item != m_PartInfoVec.end(); ++item) { cout<<*item<<endl; } } private: std::vector<const char *> m_PartInfoVec; }; // Builder class Builder { public: virtual void BuildPartA() {} virtual void BuildPartB() {} virtual Product *GetProduct() { return NULL; } }; // ConcreteBuilder class ConcreteBuilder : public Builder { public: ConcreteBuilder() { m_Product = new Product(); } void BuildPartA() { m_Product->AddPart("PartA completed"); } void BuildPartB() { m_Product->AddPart("PartB completed"); } Product *GetProduct() { return m_Product; } private: Product *m_Product; }; // Director class Director { public: Director(Builder *builder) { m_Builder = builder; } void CreateProduct() { m_Builder->BuildPartA(); m_Builder->BuildPartB(); } private: Builder *m_Builder; }; // main int main() { Builder *builderObj = new ConcreteBuilder(); Director directorObj(builderObj); directorObj.CreateProduct(); Product *productObj = builderObj->GetProduct(); if (productObj == NULL) { return 0; } productObj->ShowProduct(); delete productObj; productObj = NULL; // 谢谢宾零同学的review delete builderObj; builderObj = NULL; }
一个复杂对象是由多个部件组成的，建造者模式是把复杂对象的创建和部件的创建分别开来，分别用Builder类和Director类来表示。用Director构建最后的复杂对象，而在上面Builder接口中封装的是如何创建一个个部件（复杂对象是由这些部件组成的），也就是说，Director负责如何将部件最后组装成产品。这样建造者模式就让设计和实现解耦了。
刚开始接触建造者模式的时候，最容易把建造者和抽象工厂模式混淆了。由于而这都属于创建型的设计模式，所以二者之间是有公共点的，但是建造者模式注重于对象组合，即不同的小对象组成一个整体的复杂大对象，而抽象工厂模式针对于接口编程，只是对外提供创建对象的工厂接口，不负责对象之后的处理。
建造者模式，是一个比较复杂，不容易权衡的设计模式。大家应该更多的阅读开源代码，理解他人是如何使用该模式的。从实际的应用中学习设计模式。
标签：
原文地址：http://www.cnblogs.com/ranjiewen/p/5701100.html
