五、优缺点

一、介绍

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

二、应用场景

1、需要生成的对象具有复杂的内部结构。

2、需要生成的对象内部属性本身相互依赖。

一些基本部件不会变，而其组合经常变化的时候。

如：在肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。

三、要点

将变与不变分离开。

Builder（抽象建造者）：为创建一个产品对象的各个部件指定抽象接口。

ConcreteBuilder（具体建造者）：实现 Builder 的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并提供一个检索产品的接口。

Director（指挥者）：构造一个使用 Builder 接口的对象。

Product（产品）：表示被构造的复杂对象。ConcreteBuilder 创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

四、样例

1、创建产品：创建一个 Computer 类，它可以通过组装零件来创建。

// product.h
#ifndef PRODUCT_H
#define PRODUCT_H

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

// computer
class Computer
{
public:
	void SetmCpu(string cpu) { m_strCpu = cpu; }
	void SetMainBoard(string mainboard) { m_strMainBoard = mainboard; }
	void SetRam(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_strMainBoard; }
	string GetVideoCard() { return m_strVideoCard; }

private:
	string m_strCpu;	// CPU
	string m_strMainBoard;
	string m_strRam;
	string m_strVideoCard;
};

#endif

2、创建抽象建造者：产品类准备好就可以创建Builder类了，它提供的功能用于创建电脑各个部件。

// builder.h
#ifndef BUILDER_H
#define BUILDER_H

#include "product.h"

// 建造者接口，组装流程
class IBuilder
{
public:
        virtual void BuildCpu() = 0;
        virtual void BuildMainBoard() = 0;
        virtual void BuildRam() = 0;
        virtual void BuildVideoCard() = 0;
        virtual Computer* GetResult() = 0;        // 获取建造后产品
};

#endif

3、创建具体建造者：有了 Builder 接口，接下来的事情就是让 ConcreteBuilder 对象到位。在这些建造者中，我们可以指定每台电脑要使用的部件信息。

// concrete_builder.h
#ifndef CONCRETE_BUILDER_H
#define CONCRETE_BUILDER_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->SetMainBoard("Intel DH57DD"); }
	void BuildRam() { m_pComputer->SetRam("DDR4"); }
	void BuildVideoCard() { m_pComputer->SetVideoCard("NVDIA Geforce 920MX"); }
	Computer* GetResult() { return m_pComputer; }

private:
	Computer *m_pComputer;
};

// Yoga系列
class YogaBuilder : public IBuilder
{
public:
	YogaBuilder() { m_pComputer = new Computer(); }
	void BuildCpu() { m_pComputer->SetmCpu("i7-7500U"); }
	void BuildMainBoard() { m_pComputer->SetMainBoard("Intel DP55KG"); }
	void BuildRam() { m_pComputer->SetRam("DDR5"); }
	void BuildVideoCard() { m_pComputer->SetVideoCard("NVDIA Geforce 940MX"); }
	Computer* GetResult() { return m_pComputer; }

private:
	Computer *m_pComputer;
};

#endif

4、创建指挥者：创建一个 Director 类，让 Create 方法接受一个 IBuilder，然后在内部调用相应的组装函数。

// director.h
#ifndef DIRECTOR_H
#define DIRECTOR_H

#include "builder.h"

// 指挥者
class Director
{
public:
        void Create(IBuilder *pBuilder)
        {
                pBuilder->BuildCpu();
                pBuilder->BuildMainBoard();
                pBuilder->BuildRam();
                pBuilder->BuildVideoCard();
        }
};

#endif

5、创建客户端

// main.cpp
#include "concrete_builder.h"
#include "director.h"
#include <string>

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

int main()
{
        Director *pDirector = new Director();
        ThinkPadBuilder *pTPBuilder = new ThinkPadBuilder();
        YogaBuilder *pYogaBuilder = new YogaBuilder();

        // 组装
        pDirector->Create(pTPBuilder);
        pDirector->Create(pYogaBuilder);

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

        // 测试输出
        cout << "------ThinkPad------" << endl;
        cout << "CPU:" << pThinkPadComputer->GetCPU() << endl;
        cout << "MainBoard:" << pThinkPadComputer->GetMainBoard() << endl;
        cout << "Ram:" << pThinkPadComputer->GetRam() << endl;
        cout << "VideoCard:" << pThinkPadComputer->GetVideoCard() << endl;

        cout << "------Yoga------" << endl;
        cout << "CPU:" << pYogaComputer->GetCPU() << endl;
        cout << "MainBoard:" << pYogaComputer->GetMainBoard() << endl;
        cout << "Ram:" << pYogaComputer->GetRam() << endl;
        cout << "VideoCard:" << pYogaComputer->GetVideoCard() << endl;

        SAFE_DELETE(pYogaComputer);
        SAFE_DELETE(pThinkPadComputer);
        SAFE_DELETE(pYogaBuilder);
        SAFE_DELETE(pTPBuilder);
        SAFE_DELETE(pDirector);

        getchar();
        return 0;
}

输出：

—–ThinkPad—–
CPU : i5 - 6200U
Mainboard : Intel DH57DD
Ram : DDR4
VideoCard : NVIDIA Geforce 920MX
—–Yoga—–
CPU : i7 - 7500U
Mainboard : Intel DP55KG
Ram : DDR5
VideoCard : NVIDIA GeForce 940MX

如果需要创建更多的产品，只需要一个 ConcreteBuilder 即可，并且所有的代码都基本相同，客户端还可以使用此模式轻松地创建复杂的产品。

五、优缺点

优点：

1、建造者独立，易扩展。

2、便于控制细节风险。

缺点：

1、产品必须有共同点，范围有限制。

2、如内部变化复杂，会有很多的建造类。

03：建造者模式——C++实现

一、介绍

二、应用场景

三、要点

四、样例

五、优缺点

猜你喜欢