23种设计模式之Builder模式（四）

第三天啦，今天看一下builder模式，说实话，这篇博客https://blog.csdn.net/liang19890820/article/details/66968761写的很清晰，举的例子也很容易理解，用的就是这篇博客举得例子，比书上给的例子更容易理解。

第一部分：创建型模式

4. Builder模式

a. 问题

Builder模式的基本思想是将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。

b. 模式框图

Product（要构造的复杂对象）：如电脑
Builder（抽象建造者）：构建产品的各个部件，抽象基类。CPU，显卡、内存条等部件组成，但不同类型的电脑如联想、Apple使用的硬件并不相同。
ConcreteBuilder（具体建造者）：实现 Builder 的接口以构造和装配该产品的具体部件，最好提供一个检索产品的接口。具体化CPU，显卡、内存条等部件。在每一步的构造过程中可以引入参数，使得经过相同的步骤创建最后得到的对象的展示不一样，也即相同的组装过程得到不同的电脑。
Director（指挥者）：使用 Builder 接口，说明构建产品的流程。一般而言director并不返回产品，只是执行buildPartA，buildPartB,…, 来一步步创建对象，通过在ConcreteBuilder里写一个返回product的接口来返回最终构建的产品。

c. 代码实现

客户端

//main.cpp
#include "Builder.h" 
#include "Product.h" 
#include "Director.h"
#include <iostream>
using namespace std;

#ifndef SAFE_DELETE
#define SAFE_DELETE(p) { if(p){delete(p); (p)=NULL;} }
#endif

int main(int argc,char* argv[]) 
{ 
	Director* pDirecror = new Director();
	ThinkPadBuilder *pTPBuilder = new ThinkPadBuilder();
	YogaBuilder *pYogaBuilder = new YogaBuilder();

	// 组装 ThinkPad、Yoga
	pDirecror->Construct(pTPBuilder);
	pDirecror->Construct(pYogaBuilder);

	// 获取组装后的电脑
    Computer *pThinkPadComputer = pTPBuilder->GetResult();
    Computer *pYogaComputer = pYogaBuilder->GetResult();

	//释放内存
	SAFE_DELETE(pThinkPadComputer);
    SAFE_DELETE(pYogaComputer);
    SAFE_DELETE(pTPBuilder);
    SAFE_DELETE(pYogaBuilder);
    SAFE_DELETE(pDirecror);
	return 0; 
}

产品：产品的各个部件也可能是抽象类，这里就简单一点，直接定义为string

// product.h
#ifndef PRODUCT_H
#define PRODUCT_H

#include <iostream>

using namespace std;

// 电脑
class Computer
{
public:
    void SetmCpu(string cpu) { m_strCpu = cpu;}
    void SetmMainboard(string mainboard) { m_strMainboard = mainboard; }
    void SetmRam(string ram) { m_strRam = ram; }
    void SetVideoCard(string videoCard) { m_strVideoCard = videoCard; }

    string GetCPU() { return m_strCpu; }
    string GetMainboard()  { return m_strMainboard; }
    string GetRam() { return m_strRam; }
    string GetVideoCard() { return m_strVideoCard; }

private:
    string m_strCpu;  // CPU
    string m_strMainboard;  // 主板
    string m_strRam;  // 内存
    string m_strVideoCard;  // 显卡
};

#endif // PRODUCT_H

创建建造者基类：创建各个电脑的部件，并定义返回构建的电脑产品的接口

// builder.h
#ifndef BUILDER_H
#define BUILDER_H

#include "product.h"

// 建造者接口，组装流程
class IBuilder
{
public:
    virtual void BuildCpu() = 0;  // 创建 CPU
    virtual void BuildMainboard() = 0;  // 创建主板
    virtual void BuildRam() = 0;  // 创建内存
    virtual void BuildVideoCard() = 0;  // 创建显卡
    virtual Computer* GetResult() = 0;  // 获取建造后的产品
};

#endif // BUILDER_H

具体的建造者：

// concrete_bulider.h
#ifndef CONCRETE_BULIDER_H
#define CONCRETE_BULIDER_H

#include "builder.h"

// ThinkPad 系列
class ThinkPadBuilder : public IBuilder
{
public:
    ThinkPadBuilder() { m_pComputer = new Computer(); }    //创建各个电脑的部件
    void BuildCpu() { m_pComputer->SetmCpu("i5-6200U"); }
    void BuildMainboard() { m_pComputer->SetmMainboard("Intel DH57DD"); }
    void BuildRam() { m_pComputer->SetmRam("DDR4"); }
    void BuildVideoCard()  { m_pComputer->SetVideoCard("NVIDIA Geforce 920MX"); }
    Computer* GetResult() { return m_pComputer; }

private:
    Computer *m_pComputer;                     //定义返回的产品为private
};

// Yoga 系列
class YogaBuilder : public IBuilder
{
public:
    YogaBuilder() { m_pComputer = new Computer(); }
    void BuildCpu() { m_pComputer->SetmCpu("i7-7500U"); }
    void BuildMainboard() { m_pComputer->SetmMainboard("Intel DP55KG"); }
    void BuildRam() { m_pComputer->SetmRam("DDR5"); }
    void BuildVideoCard()  { m_pComputer->SetVideoCard("NVIDIA GeForce 940MX"); }
    Computer* GetResult() { return m_pComputer; }

private:
    Computer *m_pComputer;
};

#endif // CONCRETE_BULIDER_H

指挥：产品构建流程，传入builder，将builder按照一定流程构建成产品

// director.h
#ifndef DIRECTOR_H
#define DIRECTOR_H

#include "builder.h"

// 指挥者
class Direcror
{
public:
    void Create(IBuilder *builder) {
        builder->BuildCpu();
        builder->BuildMainboard();
        builder->BuildRam();
        builder->BuildVideoCard();
    }
};

#endif // DIRECTOR_H

d. 优缺点

优点：建造者独立，易于扩展建造者，如在组装一个新的电脑
缺点：产品必须由相同的部件类型

Builder和Abstract Factory要实现的功能很相似，都是创建一个复杂的对象，不同的是Builder多了一个指挥者，专门用于走流程，而且director不返回产品。new builder之后，director走流程创建部件，然后通过builder自己返回产品。factory是这两个部分都是factory自己做。所以factory更灵活一点，不同factory组装流程可以不同，builder需要组装流程相同。