本篇文章记录建造者模式。

建造者模式定义

建造者模式，也称为构建器模式，构建者模式，属于创建型模式。引入建造者（Builder）模式定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
通常用于创建比较复杂的对象，继续使用三个怪物类的示例说明构建者模式。

一个具体实现范例的逐步重构

还是三个怪物：亡灵类，元素类，机械类
怪物组成：头部，躯干（颈部，尾巴），肢体 三个部位组成
编码步骤：将怪物躯干部模型信息读入内存，将怪物的头部和四肢模型信息读入内存；
下面的方式类似于最初的模板方法模式。
loadTrunk(string strno) ，loadHead(string strno) ，loadLibs(string strno) 称为构建过程相关的函数。
引入与怪物类同层次的相关构建器类，把怪物类中代码搬到相关的构建器类中。

/*
    怪物类组成：头部，躯干，肢体 三部分组成。
*/
// loadTrunk    loadHead    loadLibs
class CMonster
{
public:
    
    // 组装怪物
    void setUp(string_view strmode)
    {
        loadTrunk(strmode.substr(1,2));
        loadHead(strmode.substr(3, 2));
        loadLibs(strmode.substr(5, 2));
    }
    virtual void loadTrunk(string_view str) = 0;
    virtual void loadHead(string_view str) = 0;
    virtual void loadLibs(string_view str) = 0;
};

// 创建三个怪物
class CUndead : public CMonster
{
public:
    virtual void loadTrunk(string_view str) override
    {
        cout << "组装 亡灵类躯干   " << str << endl;
    }
    virtual void loadHead(string_view str) override
    {
        cout << "组装 亡灵类头部   " << str << endl;
    }
    virtual void loadLibs(string_view str) override
    {
        cout << "组装 亡灵类四肢   " << str << endl;
    }
};

class CElement : public CMonster
{
public:
    virtual void loadTrunk(string_view str) override
    {
        cout << "组装 元素类  躯干 " << str << endl;
    }
    virtual void loadHead(string_view str) override
    {
        cout << "组装 元素类 头部  " << str << endl;
    }
    virtual void loadLibs(string_view str) override
    {
        cout << "组装 元素类  四肢 " << str << endl;
    }
};

class CMechanic : public CMonster
{
public:
    virtual void loadTrunk(string_view str) override
    {
        cout << "组装 机械类躯干   " << str << endl;
    }
    virtual void loadHead(string_view str) override
    {
        cout << "组装 机械类头部   " << str << endl;
    }
    virtual void loadLibs(string_view str) override
    {
        cout << "组装 机械类四肢   " << str << endl;
    }
};

void test()
{
    CMonster* pbase = new CMechanic();
    pbase->setUp("22558899");
    /*
        组装 机械类躯干   25
        组装 机械类头部   58
        组装 机械类四肢   89
    */
}

使用string.substr(index,N)对字符串进行了切割。
使用string_view来代替字符串，提高的效率。

引入建造者（Builder）模式

引入建造者（Builder）模式定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
CMonsterBuilder类就是对象的构建，CMonster类是对象的表示, CMonsterBuilder类种包含了CMonster类。

namespace _nmsp2
{
	class CMonster
	{
	public:
		virtual ~CMonster()
		{

		}
	};

	class CUndead : public  CMonster
	{
	public:

	};

	class CElement : public  CMonster
	{
	public:


	};

	class CMechanic : public  CMonster
	{
	public:

	};

	// 怪物类构建器 父类
	class CMonsterBuilder
	{
	public:
		virtual ~CMonsterBuilder()
		{
		}

		CMonster* getpMonster()
		{
			return pbase;
		}
		virtual void loadTrunk(string strno) = 0;
		virtual void loadHead(string strno) = 0;
		virtual void loadLibs(string strno) = 0;
		// 
	protected:
		CMonster* pbase;
	};

	// 亡灵类构建器
	class CUndeadBuilder : public CMonsterBuilder
	{
	public:
		CUndeadBuilder() //构造函数:在怪物类的构建器的构造函数中new 对应类
		{
			pbase = new CUndead();
		}
		virtual void loadTrunk(string strno)
		{
			cout << "组装 亡灵类 躯干" << endl;
		}
		virtual void loadHead(string strno)
		{
			cout << "组装 亡灵类 头部" << endl;
		}
		virtual void loadLibs(string strno)
		{
			cout << "组装 亡灵类 四肢" << endl;
		}
	};

	class CElementBuild : public CMonsterBuilder
	{
	public:
		CElementBuild()
		{
			pbase = new CElement();
		}
		virtual void loadTrunk(string strno)
		{
			cout << "组装元素类躯干" << endl;
		}
		virtual void loadHead(string strno)
		{
			cout << "组装 元素类 头部" << endl;
		}
		virtual void loadLibs(string strno)
		{
			cout << "组装 元素类 四肢" << endl;
		}
	};

	class CMeChanicBuild : public CMonsterBuilder
	{
	public:
		CMeChanicBuild()
		{
			pbase = new CMechanic();
		}
		virtual void loadTrunk(string strno)
		{
			cout << "组装 机械类 躯干" << endl;
		}
		virtual void loadHead(string strno)
		{
			cout << "组装 机械类 头部" << endl;
		}
		virtual void loadLibs(string strno)
		{
			cout << "组装 机械类 四肢" << endl;
		}

	};

	// 指挥者类
	class CMonsterDirector
	{
	public:
		CMonsterDirector(CMonsterBuilder* pbuild)
		{
			pdirector = pbuild;
		}
		// 指定新的构建器 
		void SetBuilder(CMonsterBuilder* ptmpBuilder)
		{
			pdirector = ptmpBuilder;
		}

		CMonster* construct(string strmodelno)
		{
			pdirector->loadTrunk(strmodelno.substr(4, 3));	// 截取躯干部分字符串，表示躯干的编号；
			pdirector->loadHead(strmodelno.substr(7, 3));	// 截取 头部
			pdirector->loadLibs(strmodelno.substr(10, 3)); // 截取四肢
			return pdirector->getpMonster();
		}
	private:
		CMonsterBuilder* pdirector;
	};

	void test()
	{
		_nmsp2::CMonsterBuilder* pmb = new _nmsp2::CUndeadBuilder();
		_nmsp2::CMonsterDirector* pDirect = new _nmsp2::CMonsterDirector(pmb);
		_nmsp2::CMonster* pCMonster = pDirect->construct("2222222233333333334444444");
		/*
		组装 亡灵类 躯干
		组装 亡灵类 头部
		组装 亡灵类 四肢
		*/
	}
}

构造者模式四种角色

构造者模式包含的四种角色：
1 Builder 抽象构建器，这里指CMonsterBuilder
2 具体构建器：CUndeadBuilder, CElementBuilder, CMechanicBuilder,
3 产品：这里指：CUndead, CElement, CMechanic
4 指挥者Director: CMonsterDirector

构造者模式结构

关系梳理：各个怪物与怪物构造者之间是组合关系；构造者被指挥者指挥，他们之间是聚合关系。