设计模式（2）——生成器 Builder

目录：

设计模式学习笔记首页
设计模式（1）——抽象工厂 AbstractFactory
设计模式（2）——生成器 Builder
设计模式（3）——工厂方法 Factory Method
设计模式（4）——原型 Prototype
设计模式（5）——单例 Singleton
设计模式（6）——适配器 Adapter
设计模式（7）——桥接 Bridge
设计模式（8）——组合 Composite
设计模式（9）——装饰 Decorator
设计模式（10）——外观 Facade
设计模式（11）——享元 Flyweight
设计模式（12）——代理 Proxy
设计模式（13）——职责链 Chain Of Responsibility
设计模式（14）——命令 Command
设计模式（15）——解释器 Interpreter
设计模式（16）——迭代器 Iterator
设计模式（17）——中介者 Mediator
设计模式（18）——备忘录 Memento
设计模式（19）——观察者 Observer
设计模式（20）——状态 State
设计模式（21）——策略 Strategy
设计模式（22）——模板方法 Template Method
设计模式（23）——访问者 Visitor

二、Builder （生成器模式，对象创建型模式）

1. 问题：

  一个对象的创建经过很多步骤，通常由很多其他对象组合而成。

2. 功能：

  可以在每一步的构造过程中引入参数，使得经过相同的步骤创建最后得到的对象的展示不一样，即生成器模式暴露出一组标准的构建产品的抽象方法，允许用户参与到构建产品的过程中，以控制产品的生成。

3. 意图：

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

4. 类图：

5. Builder 模式与 AbstractFactory 模式的区别：

1. 二者功能上很相似，Builder 强调的是一步步创建对象，并通过相同的创建过程可以获得不同的结果对象。而 AbstractFactory 强调的是为创建多个相互依赖的对象提供一个同一的接口。
2. 如果一个产品只有一个构造过程，那么生成器模式就退化成了简单工厂模式。

6. C++实现：

  http://blog.csdn.net/leonliu06/article/details/78446271
1. 先写一个 Builder 生成器类
2. Builder 类中编写各个构建产品的方法 void BuildPartA(stirng para);...
3. 再写一个 Director 导向器类, Director 包含一个 Builder
4. Builder 类中编写一个总的构建方法 void Construct(); 调用 Builder 中的各个构建方法

Builder.h

// Builder.h
#pragma once

#include <iostream>
#include <string>

using namespace std;

class Product;

class Builder {
public:
    virtual ~Builder();

    virtual void BuildPartA(const string& buildPara) = 0;
    virtual void BuildPartB(const string& buildPara) = 0;
    virtual void BuildPartC(const string& buildPara) = 0;

    virtual Product* GetProduct() = 0;

protected:
    Builder();

private:
};

class ConcreteBuilder :public Builder {
public:
    ConcreteBuilder();
    ~ConcreteBuilder();
    void BuildPartA(const string& buildPara);
    void BuildPartB(const string& buildPara);
    void BuildPartC(const string& buildPara);
    Product* GetProduct();

protected:
private:
    Product* _product;

};

Builder.cpp

// Builder.cpp
#include "Builder.h"
#include "Product.h"

#include <iostream>

using namespace::std;

Builder::Builder() {}
Builder::~Builder() {}
ConcreteBuilder::ConcreteBuilder() {
    _product = new Product();
}
ConcreteBuilder::~ConcreteBuilder() {}

void ConcreteBuilder::BuildPartA(const string& buildPara) {
    cout << "Step1: Build PartA..." << buildPara << endl;
    _product->ProducePart(buildPara);   
}

void ConcreteBuilder::BuildPartB(const string& buildPara) {
    cout << "Step2: Build PartB..." << buildPara << endl;
    _product->ProducePart(buildPara);
}

void ConcreteBuilder::BuildPartC(const string& buildPara) {
    cout << "Step3: Build PartC..." << buildPara << endl;
    _product->ProducePart(buildPara);
}

Product* ConcreteBuilder::GetProduct() {
    return _product;
}

Director.h

// Director.h
#pragma once

#include <string>

using namespace::std;

class Builder;
class Director {
public:
    Director(Builder* bld);
    ~Director();
    void Construct(string, string, string);
protected:
private:
    Builder* _bld;
};

Director.cpp

// Directory.cpp
#include "Director.h"
#include "Builder.h"

Director::Director(Builder* bld){
    _bld = bld;
}
Director::~Director() {}
void Director::Construct(string a, string b, string c) {
    _bld->BuildPartA(a);
    _bld->BuildPartB(b);
    _bld->BuildPartC(c);
}

Product.h

// Product.h
#pragma once

#include <string>
using namespace::std;

class Product {
public:
    Product();
    ~Product();
    void ProducePart(string part);
    void PrintProduct();
protected:

private:
    string _name = "";
};

Product.cpp

#include "Product.h"

#include <iostream>

using namespace::std;

Product::Product() {}
Product::~Product() {}

void Product::ProducePart(string part){
    cout << part;
    _name += part;
}

void Product::PrintProduct() {
    cout << "The builded product is: \n" << _name << endl;
}

main.cpp

// main.cpp
#include "Builder.h"
#include "Product.h"
#include "Director.h"
#include <iostream>

using namespace::std;

int main(int argc, char* argv[]) {
    Builder* b = new ConcreteBuilder();
    Director* d = new Director(b);

    d->Construct("Hello ", "C++ ", "Language");

    Product* product = b->GetProduct();

    product->PrintProduct();

    return 0;
}