1. 作用

建造者模式是对象创建型模式的一种,相对工厂模式系列稍微复杂。
意图：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
核心：同样的构建过程可以创建不同的表示。简单说就是同样的创建对象过程可以产生不同的对象。

2. UML类图

这里写图片描述

Product：表示被构造的复杂对象。通常有众多的必要组件构成。
Builder：为创建一个Product对象的各个部件指定抽象接口。
ConcreteBuilder：实现Builder的接口以构造和装配该产品的各个部件。为Product指定不同的部件。
Director：构造一个使用Builder的接口对象。

3. 实现

举例：电脑现在是我们日常生活中离不开的工具，联想和苹果是两个比较大的电脑厂家。假设电脑有CPU，主板，内存，显卡组成，两家公司的电脑产品在这些配置上肯定是不相同的。用代码表示其生产过程。
代码：


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


/****电脑*****/
class Pc
{
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; }

    void showMe()
    {
        cout << "CPU: " + m_strCpu << "主板： "+m_strMainboard <<"内存： "+ m_strRam <<"显卡： "+ m_strVideoCard << endl;;
    }

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


/****电脑生产抽象类***/
class PcBuilder
{
public:
    Pc *getPc()// 获取建造后的产品
    {
        return m_pPc;
    }

    virtual void BuildCpu(){}           // 创建 CPU
    virtual void BuildMainboard(){}     // 创建主板
    virtual void BuildRam(){}           // 创建内存
    virtual void BuildVideoCard(){}     // 创建显卡
protected:
    Pc *m_pPc;
};


/****联想电脑****/
class LenovoBuilder :public PcBuilder
{
public:
    LenovoBuilder() { m_pPc = new Pc(); }  
    void BuildCpu() { m_pPc->SetmCpu("i5-6200U"); }                 //设置CPU
    void BuildMainboard() { m_pPc->SetmMainboard("Intel DH57DD"); } //设置主板
    void BuildRam() { m_pPc->SetmRam("DDR4"); }                     //设置内存
    void BuildVideoCard()  { m_pPc->SetVideoCard("NVIDIA Geforce 920MX"); }//设置显卡
};

/****苹果电脑****/
class AppleBuilder : public PcBuilder
{
public:
    AppleBuilder() { m_pPc = new Pc(); }
    void BuildCpu() { m_pPc->SetmCpu("A10"); }//设置CPU
    void BuildMainboard() { m_pPc->SetmMainboard("Intel DP55KG"); }//设置主板
    void BuildVideoCard()  { m_pPc->SetVideoCard("NVIDIA GeForce 940MX"); }//设置显卡
};



/***导演类：在他眼里所有电脑的生成过程应该是一样的，仅仅封装建造者的接口***/
class Direcror
{
public:
    Pc* Create(PcBuilder *builder) {
        builder->BuildCpu();
        builder->BuildMainboard();
        builder->BuildRam();
        builder->BuildVideoCard();

        return builder->getPc();
    }
};


/***开始生成电脑****/

int main()
{
    //导演类
    Direcror *pDirecror = new Direcror();
    PcBuilder *pLenovoBuilder = new LenovoBuilder();
    PcBuilder *pAppleBuilder = new AppleBuilder();

    //组装联想电脑
    Pc *plenovoPc = pDirecror->Create(pLenovoBuilder);

    //组装苹果电脑
    Pc *pApplePc = pDirecror->Create(pAppleBuilder);

    // 显示组装后的电脑
    plenovoPc->showMe();

    pApplePc->showMe();


    delete pDirecror;
    delete pLenovoBuilder;
    delete pAppleBuilder;
    delete plenovoPc;
    delete pApplePc;
    return 0;
}

结果：
CPU: i5-6200U主板： Intel DH57DD内存： DDR4显卡： NVIDIA Geforce 920MX
CPU: A10主板： Intel DP55KG内存：显卡： NVIDIA GeForce 940MX
请按任意键继续…

ps：如果不同的创建顺序会产生不同的对象，可以将创建顺序封装于ConcreteBuilder中。

4. 优缺点

优点:
同样将对象的具体创建过程进行了封装。
建造者独立，容易扩展，比如增加一个戴尔品牌电脑。
便于控制对象创建过程的细节。
缺点：
产品必须有相同的特征，即共同的组成部件。
如果内部变化复杂，将会有很多的建造类，一般一类对象对应一个建造类。

5. 使用场景

创建过程贯穿于建造者模式。
相同的方法。不同的执行顺序，不同的组成部件产生不同的对象都可以使用建造者模式。

6. 总结

建造者模式注重对象的组成和创建过程，工厂模式只注重对象的整体创建，二者侧重点还是非常明显的。

设计模式之建造者模式（C++）