【设计模式】建造者(生成器)

生成器模式，也叫建造者模式。有人说后者是想强调该模式重点是强调建造过程，而不是生成。

个人比较认同，所以后文也叫建造者模式。

建造者模式，主要意图是将对象的建造于他的表示分离。从而使得同样的建造过程可以建造出不同的产品。

参与者有建造者，导演和具体的产品。

举例说明，我们想生产电脑，电脑就是产品。声明一个类，叫builder，而具体的建造者，需要继承自这个父类，并实现其构造方法，并最终返回构造后的产品。

这里变化的部分就是，不同的建造者和构造过程。建造者可以通过继承出新的类来实现扩展。

而建造过程，通过一个director类来封装。每个过程可以对应一个新的导演。导演负责调用具体建造者对应的建造方法。并最终获取其生产的产品。

/**
 * @file test_builder.cpp
 * @author itegel
 * @date 2013/09/12 10:07:27
 * @brief 
 *  
 **/

#include <iostream>
#include <string>
using namespace std;

class ComputerBuilder{
public:
    ComputerBuilder(){}
    virtual ~ComputerBuilder(){}
    virtual void BuildBody(){
        cout<<"no body!"<<endl;
    }
    virtual void BuildScreen(){
        cout<<"no screen!"<<endl;
    }
    virtual void BuildMouse(){
        cout<<"no mouse!"<<endl;
    }
    virtual void BuildKeybord(){
        cout<<"no keybord!"<<endl;
    }
    virtual string GetResult() = 0;
};

class PCBuilder: public ComputerBuilder{
public:
    PCBuilder(){
        m_result = "A PC With: ";
    }
    virtual ~PCBuilder(){}
    virtual void BuildBody(){
        cout<<"PC body built!"<<endl;
        m_result += "a Body; ";
    }
    virtual void BuildScreen(){
        cout<<"PC screen built!"<<endl;
        m_result += "a Screen; ";
    }
    virtual void BuildMouse(){
        cout<<"PC mouse built!"<<endl;
        m_result += "a Mouse; ";
    }
    virtual void BuildKeybord(){
        cout<<"PC keybord built!"<<endl;
        m_result += "a Keybord; ";
    }
    virtual string GetResult(){
        return m_result;
    }
private:
    string m_result;
};

class IPadBuilder: public ComputerBuilder{
public:
    IPadBuilder(){
        m_result = "An Ipad With: ";
    }
    virtual ~IPadBuilder(){}
    virtual void BuildBody(){
        cout<<"IPad body built!"<<endl;
        m_result += "a Body; ";
    }
    virtual void BuildScreen(){
        cout<<"IPad screen built!"<<endl;
        m_result += "a Screen; ";
    }
    virtual string GetResult(){
        return m_result;
    }
private:
    string m_result;
};

class Director{
public:
    Director(ComputerBuilder * computer_builder):m_computer_builder(computer_builder){}
    virtual ~Director(){}
    void ConstructComputer(){
        m_computer_builder->BuildBody();
        m_computer_builder->BuildScreen();
        m_computer_builder->BuildMouse();
        m_computer_builder->BuildKeybord();
        cout<<"RESULT:"<<endl<<"\t"<<m_computer_builder->GetResult()<<endl;
    }
private:
    ComputerBuilder * m_computer_builder;
};

int main(){
    cout<<"pc builder working..."<<endl;
    ComputerBuilder * tmp_builder = new PCBuilder();
    Director director1(tmp_builder);
    director1.ConstructComputer();
        
    cout<<endl<<"Ipad builder working..."<<endl;
    ComputerBuilder * tmp_builder2 = new IPadBuilder();
    Director director2(tmp_builder2);
    director2.ConstructComputer();

    return 0;
}

输出如下：

pc builder working...
PC body built!
PC screen built!
PC mouse built!
PC keybord built!
RESULT:
        A PC With: a Body; a Screen; a Mouse; a Keybord; 

Ipad builder working...
IPad body built!
IPad screen built!
no mouse!
no keybord!
RESULT:
        An Ipad With: a Body; a Screen; 

该模式，主要是分离了具体组装过程和每个过程的实现。适用于构造过程复杂，并且可以有多种建造方式的场景。建造过程和不同的建造方法很容易扩展。

缺点看起来是客户端需要知道有哪些建造者和建造过程。由客户端来选择具体的导演类和建造者。如果客户端不关注这些，那么就不适用了。

跟抽象工厂的区别是，抽象工厂强调多个系列产品兑现搞得构造方式，而建造者强调构造一个复杂对象的过程。