C++设计模式——建造者模式

建造者模式

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

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

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

UML图

类图如下：

时序图如下：

代码实现

/*****************************************************

* \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() = ;

    virtual void buildBody() = ;

    virtual void buildLeftHand() = ;

    virtual void buildRightHand() = ;

    virtual void buildLeftFoot() = ;

    virtual void buildRightFoot() = ;

    virtual Man* getMan() = ;

};

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 ;

}

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

#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 ;

    }

    productObj->ShowProduct();

        delete productObj;

        productObj = NULL; // 谢谢宾零同学的review

    delete builderObj;

    builderObj = NULL;

}

使用要点

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

总结

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

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

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

巴特西

C++设计模式——建造者模式

建造者模式

UML图

代码实现

使用要点

总结

最新文章

热门文章