设计模式之创建者模式

生成器（创建者）模式和工厂模式都属于创建型设计模式。

前一篇文章简述了简单工厂，工厂方法和抽象工厂的差异。那么生成器模式和工厂模式有什么区别呢。

总结下：M为工厂类数，N为产品类数
工厂模式 比例关系为 1：N/M

简单工厂 M=1（无论多少种产品只有一种工厂）
工厂方法 是 M=N（多少种产品就有多少种工厂）
而抽象工厂是 抽象类别 = N/M （在两个产品层级关系下）

而本文所说的生成器模式，则是在一种产品的前提下讨论的。生成器其实不是产生对象，用确切点的话来说可以看成是构造对象，是一个过程。

代码：

/**
 * @author  nhpeng,nhpeng1104@gmail.com
 * @date    2015/08/18 10:08:56 CST
 * @brief   建造者模式
 *
 * 
 */

#include <stdio.h>
#include <string>

class Battle
{
    public:
        Battle( ){};
        ~Battle( ){};

        void SetPartA( std::string partA ){ m_partA = partA; };
        void SetPartB( std::string partB ){ m_partB = partB; };
        void SetPartC( std::string partC ){ m_partC = partC; };
        void SetPartD( std::string partD ){ m_partD = partD; };

        void Show( )
        {   
            printf( "%s - %s - %s - %s\n", m_partA.c_str( ), m_partB.c_str( ), m_partC.c_str( ), m_partD.c_str( ) );
        };  
    private:
        std::string m_partA;
        std::string m_partB;
        std::string m_partC;
        std::string m_partD;
};

class Builder
{
    public:
        Builder( Battle *battle );
        virtual ~Builder( ){};

        virtual void CreateBattle( ){};

    protected:
        Battle *m_battle;
};

Builder::Builder( Battle *battle )
{
    m_battle = battle;
}

class BuilderA : public Builder
{
    public:
        BuilderA( Battle *battle );
        virtual ~BuilderA( ){};

        virtual void CreateBattle( );
};

BuilderA::BuilderA( Battle *battle )
:Builder( battle )
{
}

void BuilderA::CreateBattle( )
{
    m_battle->SetPartA( "BuilderA PartA" );
    m_battle->SetPartB( "BuilderA PartB" );
    m_battle->SetPartC( "BuilderA PartC" );
    m_battle->SetPartD( "BuilderA PartD" );
}

class BuilderB : public Builder
{
    public:
        BuilderB( Battle *battle );
        virtual ~BuilderB( ){};

        virtual void CreateBattle( );
};

BuilderB::BuilderB( Battle *battle )
:Builder( battle )
{
}

void BuilderB::CreateBattle( )
{
    m_battle->SetPartA( "BuilderB PartA" );
    m_battle->SetPartB( "BuilderB PartB" );
    m_battle->SetPartC( "BuilderB PartC" );
    m_battle->SetPartD( "BuilderB PartD" );
}

int main( )
{
    Battle *battle1 = new Battle( );
    BuilderA builderA( battle1 );
    builderA.CreateBattle( );
    battle1->Show( );
    delete battle1;
    Battle *battle2 = new Battle( );
    BuilderB builderB( battle2 );
    builderB.CreateBattle( );
    battle2->Show( );
    delete battle2;
    return 0;
}

自己写一遍就能够理解我上面总结出来的话了。battle1和battle2都不是BuilderA和BuilderB生成的，
他们只是再次构造了一下这两个对象。
两个生成器BuilderA，BuilderB，顺序相同（其实貌似顺序也可以不同的），材料不同（BuilderA PartA，BuilderB PartA），个人觉得构造者模式这个名字挺贴切；