设计模式（三）建造者模式（转）

超、凢脫俗 2022-06-07 05:40 138阅读 0赞

[设计模式（三）建造者模式（转）][Link 1]

原文地址：[http://www.jellythink.com/archives/98][http_www.jellythink.com_archives_98]

# [C++设计模式——建造者模式][http_www.jellythink.com_archives_98] #

#### 建造者模式 ####

在GOF的《设计模式 可复用面向对象软件的基础》中是这样说的：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

这句话，似懂非懂的。一个复杂对象的创建，其通常是由很多的子对象构成；如果一个对象能够直接就创建好了，那么也不会称之为复杂对象。由于项目中需求的变化，这个复杂对象的各个部分经常会发生剧烈的变化，但是，不管怎么变化，将它们组合在一起，组成一个复杂的对象的事实是不会变的。建造者模式就提供了一种“封装机制”来将各个对象的变化隔离开，最终，组合成复杂对象的过程是不会变的。

在《大话设计模式》一书中，例举了一个很好的例子————建造小人。建造一个小人，要分为六步：头部、身体、左手、右手、左脚和右脚。与抽象工厂模式不同的是，建造者模式是在Director的控制下一步一步的构造出来的，在建造的过程中，建造者模式可以进行更精细的控制。不管人的头部、身体、左手、右手、左脚或者右脚如何变化，但是最终还是由这几部分组合在一起形成一个人，虽然是同一个建造过程，但是这个人就会有不同的表示，比如，胖子，瘦子，个高的，个低的等等。

#### UML图 ####

类图如下：

时序图如下：

#### 代码实现 ####

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 /*
      2 ** FileName     : BuilderPattern
      3 ** Author       : Jelly Young
      4 ** Date         : 2013/11/22
      5 ** Description  : More information, please go to http://www.jellythink.com
      6 */
      7 
      8 #include <iostream>
      9 using namespace std;
     10 
     11 typedef enum MANTYPETag
     12 {
     13     kFatMan,
     14     kThinMan,
     15     kNormal
     16 }MANTYPE;
     17 
     18 class Man
     19 {
     20 public:
     21     void SetHead(MANTYPE type){ m_Type = type; }
     22     void SetBody(MANTYPE type){ m_Type = type; }
     23     void SetLeftHand(MANTYPE type){ m_Type = type; }
     24     void SetRightHand(MANTYPE type){ m_Type = type; }
     25     void SetLeftFoot(MANTYPE type){ m_Type = type; }
     26     void SetRightFoot(MANTYPE type){ m_Type = type; }
     27     void ShowMan()
     28     {
     29         switch (m_Type)
     30         {
     31         case kFatMan:
     32             cout<<"I'm a fat man"<<endl;
     33             return;
     34 
     35         case kThinMan:
     36             cout<<"I'm a thin man"<<endl;
     37             return;
     38 
     39         default:
     40             cout<<"I'm a normal man"<<endl;
     41             return;
     42         }
     43     }
     44 
     45 private:
     46     MANTYPE m_Type;
     47 };
     48 
     49 // Builder
     50 class Builder
     51 {
     52 public:
     53     virtual void BuildHead(){}
     54     virtual void BuildBody(){}
     55     virtual void BuildLeftHand(){}
     56     virtual void BuildRightHand(){}
     57     virtual void BuildLeftFoot(){}
     58     virtual void BuildRightFoot(){}
     59     virtual Man *GetMan(){ return NULL; }
     60 };
     61 
     62 // FatManBuilder
     63 class FatManBuilder : public Builder
     64 {
     65 public:
     66     FatManBuilder(){ m_FatMan = new Man(); }
     67     void BuildHead(){ m_FatMan->SetHead(kFatMan); }
     68     void BuildBody(){ m_FatMan->SetBody(kFatMan); }
     69     void BuildLeftHand(){ m_FatMan->SetLeftHand(kFatMan); }
     70     void BuildRightHand(){ m_FatMan->SetRightHand(kFatMan); }
     71     void BuildLeftFoot(){ m_FatMan->SetLeftFoot(kFatMan); }
     72     void BuildRightFoot(){ m_FatMan->SetRightFoot(kFatMan); }
     73     Man *GetMan(){ return m_FatMan; }
     74 
     75 private:
     76     Man *m_FatMan;
     77 };
     78 
     79 // ThisManBuilder
     80 class ThinManBuilder : public Builder
     81 {
     82 public:
     83     ThinManBuilder(){ m_ThinMan = new Man(); }
     84     void BuildHead(){ m_ThinMan->SetHead(kThinMan); }
     85     void BuildBody(){ m_ThinMan->SetBody(kThinMan); }
     86     void BuildLeftHand(){ m_ThinMan->SetLeftHand(kThinMan); }
     87     void BuildRightHand(){ m_ThinMan->SetRightHand(kThinMan); }
     88     void BuildLeftFoot(){ m_ThinMan->SetLeftFoot(kThinMan); }
     89     void BuildRightFoot(){ m_ThinMan->SetRightFoot(kThinMan); }
     90     Man *GetMan(){ return m_ThinMan; }
     91 
     92 private:
     93     Man *m_ThinMan;
     94 };
     95 
     96 // Director
     97 class Director
     98 {
     99 public:
    100     Director(Builder *builder) { m_Builder = builder; }
    101     void CreateMan();
    102 
    103 private:
    104     Builder *m_Builder;
    105 };
    106 
    107 void Director::CreateMan()
    108 {
    109     m_Builder->BuildHead();
    110     m_Builder->BuildBody();
    111     m_Builder->BuildLeftHand();
    112     m_Builder->BuildRightHand();
    113     m_Builder->BuildLeftHand();
    114     m_Builder->BuildRightHand();
    115 }
    116 
    117 int main(int argc, char *argv[])
    118 {
    119     Builder *builderObj = new FatManBuilder();
    120     Director directorObj(builderObj);
    121     directorObj.CreateMan();
    122     Man *manObj = builderObj->GetMan();
    123     if (manObj == NULL)
    124         return 0;
    125 
    126     manObj->ShowMan();
    127 
    128     delete manObj; // 感谢张小张同学的review
    129     manObj = NULL;
    130 
    131     delete builderObj;
    132     builderObj = NULL;
    133 
    134     return 0;
    135 };

上面这个例子比较杂，但是也是建造者模式的应用。下面这个例子是建造者最一般，最简单的实现方法：

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 /*
     2 ** FileName     : BuilderPattern
     3 ** Author       : Jelly Young
     4 ** Date         : 2013/11/23
     5 ** Description  : More information, please go to http://www.jellythink.com
     6 */
     7 
     8 #include <iostream>
     9 #include <vector>
    10 using namespace std;
    11 
    12 class Builder;
    13 
    14 // Product
    15 class Product
    16 {
    17 public:
    18     void AddPart(const char *info) { m_PartInfoVec.push_back(info); }
    19     void ShowProduct()
    20     {
    21         for (std::vector<const char *>::iterator item = m_PartInfoVec.begin(); 
    22             item != m_PartInfoVec.end(); ++item)
    23         {
    24             cout<<*item<<endl;
    25         }
    26     }
    27 
    28 private:
    29     std::vector<const char *> m_PartInfoVec;
    30 };
    31 
    32 // Builder
    33 class Builder
    34 {
    35 public:
    36     virtual void BuildPartA() {}
    37     virtual void BuildPartB() {}
    38     virtual Product *GetProduct() { return NULL; }
    39 };
    40 
    41 // ConcreteBuilder
    42 class ConcreteBuilder : public Builder
    43 {
    44 public:
    45     ConcreteBuilder() { m_Product = new Product(); }
    46     void BuildPartA()
    47     {
    48         m_Product->AddPart("PartA completed");
    49     }
    50 
    51     void BuildPartB()
    52     {
    53         m_Product->AddPart("PartB completed");
    54     }
    55 
    56     Product *GetProduct() { return m_Product; }
    57 
    58 private:
    59     Product *m_Product;
    60 };
    61 
    62 // Director
    63 class Director
    64 {
    65 public:
    66     Director(Builder *builder) { m_Builder = builder; }
    67     void CreateProduct()
    68     {
    69         m_Builder->BuildPartA();
    70         m_Builder->BuildPartB();
    71     }
    72 
    73 private:
    74     Builder *m_Builder;
    75 };
    76 
    77 // main
    78 int main()
    79 {
    80     Builder *builderObj = new ConcreteBuilder();
    81     Director directorObj(builderObj);
    82     directorObj.CreateProduct();
    83     Product *productObj = builderObj->GetProduct();
    84     if (productObj == NULL)
    85     {
    86         return 0;
    87     }
    88     productObj->ShowProduct();
    89 
    90         delete productObj;
    91         productObj = NULL; // 谢谢宾零同学的review
    92     delete builderObj;
    93     builderObj = NULL;
    94 }

通过比较上面的两个例子，可以很容易的把建造者模式的骨架抽象出来。

#### 使用要点 ####

1.  建造者模式生成的对象有复杂的内部结构，将分步骤的去构建一个复杂的对象，分多少步是确定的，而每一步的实现是不同的，可能经常发生变化；
2.  在上面的例子中，我们都看到了最终生成的Man和Product都没有抽象类，这又导出建造者适用的一种情况，当需要创建复杂对象的过程中，复杂对象没有多少共同的特点，很难抽象出来时，而复杂对象的组装又有一定的相似点时，建造者模式就可以发挥出作用。简单的说，可能使用了建造者模式，最终建造的对象可能没有多大的关系，关于这一点，阅读《设计模式 可复用面向对象软件的基础》中的建造者模式时是最有体会的。

#### 总结 ####

一个复杂对象是由多个部件组成的，建造者模式是把复杂对象的创建和部件的创建分别开来，分别用Builder类和Director类来表示。用Director构建最后的复杂对象，而在上面Builder接口中封装的是如何创建一个个部件（复杂对象是由这些部件组成的），也就是说，Director负责如何将部件最后组装成产品。这样建造者模式就让设计和实现解耦了。

刚开始接触建造者模式的时候，最容易把建造者和抽象工厂模式混淆了。由于而这都属于创建型的设计模式，所以二者之间是有公共点的，但是建造者模式注重于对象组合，即不同的小对象组成一个整体的复杂大对象，而抽象工厂模式针对于接口编程，只是对外提供创建对象的工厂接口，不负责对象之后的处理。

建造者模式，是一个比较复杂，不容易权衡的设计模式。大家应该更多的阅读开源代码，理解他人是如何使用该模式的。从实际的应用中学习设计模式。

[Link 1]: http://www.cnblogs.com/dongsheng/p/5227510.html
[http_www.jellythink.com_archives_98]: http://www.jellythink.com/archives/98
[ContractedBlock.gif]: http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif
[ExpandedBlockStart.gif]: /images/20220607/388ba59f98cd49b490adb104891e2cec.png