创建型模式-生成器(builder)

生成器

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示.

实例

main.cc:

/*
design_patterns:"builder"
In the production of mobile phones, for example, now the mobile phone manufacturers will launch high-end, midrange, 
low-end configuration version, the basic configuration of most of them, only a few key parts are different, it is very suitable 
for the use of Builder mode

high-end :835 Processor,5.5 inch Panel,8G Memory.
midrange :820 Processor,4.7 inch Panel,4G Memory.
low-end  :810 Processor,4.0 inch Panel,2G Memory.
*/
#include "builder.h"
#include "high_phone_builder.h"
#include "normal_phone_builder.h"
#include "low_phone_builder.h"
#include "director.h"
#include "phone.h"
#include <windows.h>
#include <iostream>

void main(){
    //create director
    Director *director = new Director();

    Builder *high_builder = new HighPhoneBuilder();
    director->SetBuilder(high_builder);
    //create high-end phone
    Phone *high_phone = director->AssemblePhone();
    high_phone->ShowConfig();

    Builder *normal_builder = new NormalPhoneBuilder();
    director->SetBuilder(normal_builder);

    //create midrange phone
    Phone *normal_phone = director->AssemblePhone();
    normal_phone->ShowConfig();

    Builder *low_builder = new LowPhoneBuilder();
    director->SetBuilder(low_builder);
    //create low-end phone
    Phone *low_phone = director->AssemblePhone();
    low_phone->ShowConfig();

    //clear
    delete high_builder;
    delete normal_builder;
    delete low_builder;
    delete director;
    cout << "ending!" << endl;
    system("Pause");
}

Director:

//director.h
#ifndef HELENDP_SOURCE_DIRECTOR_H_
#define HELENDP_SOURCE_DIRECTOR_H_
#include "phone.h"
#include "builder.h"

class Director{
public:
    Director();
    ~Director();
    Phone *AssemblePhone();
    void SetBuilder(Builder *builder);
private:
    Builder *builder_;
};
#endif


//director.cc
#include "director.h"
#include "builder.h"

Director::Director(){

}

Director::~Director(){

}

Phone *Director::AssemblePhone(){
    builder_->AssembleStepOne();
    builder_->AssembleStepTwo();
    builder_->AssembleStepThree();
    return builder_->GetPhone();
}

void Director::SetBuilder(Builder *builder){
    builder_ = builder;
}

Builder:

//builder.h
#ifndef HELENDP_SOURCE_BUILDER_H_
#define HELENDP_SOURCE_BUILDER_H_
#include <string>
#include "phone.h"
using namespace std;

class Builder{
public:
    Builder();
    virtual ~Builder();
    virtual void AssembleStepOne() = 0;
    virtual void AssembleStepTwo() = 0;
    virtual void AssembleStepThree() = 0;
    virtual Phone* GetPhone() = 0;
};
#endif


//builder.cc
#include "builder.h"
#include <iostream>
using namespace std;

Builder::Builder(){
}

Builder::~Builder(){
}

HighPhoneBuilder:

//high_phone_builder.h
#ifndef HELENDP_SOURCE_HIGH_PHONE_BUILDER_H_
#define HELENDP_SOURCE_HIGH_PHONE_BUILDER_H_
#include "builder.h"
#include "Phone.h"

class HighPhoneBuilder:public Builder{
public:
    HighPhoneBuilder();
    ~HighPhoneBuilder();
    void AssembleStepOne();
    void AssembleStepTwo();
    void AssembleStepThree();
    Phone* GetPhone();
private:    
    Phone *phone_;
};
#endif


//high_phone_builder.cc
#include "high_phone_builder.h"

HighPhoneBuilder::HighPhoneBuilder(){
    phone_ = new Phone();
}

HighPhoneBuilder::~HighPhoneBuilder(){
    delete phone_;
}

void HighPhoneBuilder::AssembleStepOne(){
    phone_->AssembleProcessor("SnapDragon835");
}

void HighPhoneBuilder::AssembleStepTwo(){
    phone_->AssembleMemory("8G Memory");
}

void HighPhoneBuilder::AssembleStepThree(){
    phone_->AssemblePanel("5.5 inch panel");
}
Phone* HighPhoneBuilder::GetPhone(){
    return phone_;
}

LowPhoneBuilder:

//low_phone_builder.h
#ifndef HELENDP_SOURCE_LOW_PHONE_BUILDER_H_
#define HELENDP_SOURCE_LOW_PHONE_BUILDER_H_
#include "builder.h"
#include "phone.h"

class LowPhoneBuilder:public Builder{
public:
    LowPhoneBuilder();
    ~LowPhoneBuilder();
    void AssembleStepOne();
    void AssembleStepTwo();
    void AssembleStepThree();
    Phone* GetPhone();
private:
    Phone* phone_;
};
#endif

//low_phone_builder.cc
#include "low_phone_builder.h"

LowPhoneBuilder::LowPhoneBuilder(){
    phone_ = new Phone();
}

LowPhoneBuilder::~LowPhoneBuilder(){
    delete phone_;
}

void LowPhoneBuilder::AssembleStepOne(){
    phone_->AssembleProcessor("SnapDragon810");
}

void LowPhoneBuilder::AssembleStepTwo(){
    phone_->AssembleMemory("2G Memory");
}

void LowPhoneBuilder::AssembleStepThree(){
    phone_->AssemblePanel("4.0 inch panel");
}

Phone* LowPhoneBuilder::GetPhone(){
    return phone_;
}

NormalPhoneBuilder:

//normal_phone_builder.h
#ifndef HELENDP_SOURCE_NORMAL_PHONE_BUILDER_H_
#define HELENDP_SOURCE_NORMAL_PHONE_BUILDER_H_
#include "builder.h"
#include "phone.h"

class NormalPhoneBuilder:public Builder{
public:
    NormalPhoneBuilder();
    ~NormalPhoneBuilder();
    void AssembleStepOne();
    void AssembleStepTwo();
    void AssembleStepThree();
    Phone* GetPhone();
private:
    Phone* phone_;
};
#endif


//normal_phone_builder.cc
#include "normal_phone_builder.h"

NormalPhoneBuilder::NormalPhoneBuilder(){
    phone_ = new Phone();
}

NormalPhoneBuilder::~NormalPhoneBuilder(){
    delete phone_;
}

void NormalPhoneBuilder::AssembleStepOne(){
    phone_->AssembleProcessor("SnapDragon820");
}

void NormalPhoneBuilder::AssembleStepTwo(){
    phone_->AssembleMemory("4G Memory");
}

void NormalPhoneBuilder::AssembleStepThree(){
    phone_->AssemblePanel("4.7 inch panel");
}

Phone* NormalPhoneBuilder::GetPhone(){
    return phone_;
}

Phone:

//phone.h
#ifndef HELENDP_SOURCE_PHONE_H_
#define HELENDP_SOURCE_PHONE_H_
#include <string>
using namespace std;

/*
Mobile phone includes processor, memory, panel and other basic configuration
*/
class Phone{
public:
    Phone();
    ~Phone();
    void AssembleProcessor(string processor);
    void AssembleMemory(string memory);
    void AssemblePanel(string panel);
    void ShowConfig();
private:
    string processor_;
    string memory_;
    string panel_;
    string base_config_;
};
#endif


//phone.cc
#include "phone.h"
#include <iostream>
using namespace std;

Phone::Phone(){
    base_config_ = "base config";
}

Phone::~Phone(){

}

void Phone::AssembleProcessor(string processor){
    processor_ = processor;
}

void Phone::AssembleMemory(string memory){
    memory_ = memory;
}

void Phone::AssemblePanel(string panel){
    panel_ = panel;
}

void Phone::ShowConfig(){
    cout << "ShowConfig:" << endl;
    cout << base_config_ << endl;
    cout << processor_ << endl;
    cout << memory_ << endl;
    cout << panel_ << endl << endl;
}

代码和UML图(EA)工程文件,最后会整理打包上传.

UML类图

结构

• Director(Director):指挥者
• Builder(Builder):抽象建造者
• ConcreteBuilder(HighPhoneBuilder,LowPhoneBuilder,NormalPhoneBuilder):具体建造者
• Product(Phone):产品角色

优点

• 在建造者模式中， 客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象.
• 每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者， 用户使用不同的具体建造者即可得到不同的产品对象.
• 可以更加精细地控制产品的创建过程 .将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程.
• 增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合“开闭原则”.

缺点

• 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制.
• 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大.