也是属于对象创建类模式。使用的一般情况是，需要完成一个复杂的对象创建工作，工作通常由各个部分的子对象用一定的算法构成，比如step1,step2,step3，步骤内部常常发生剧烈的变化，但是组合在一起的算法却相对的稳定。（就是构建一个东西需要好多步骤去组合才能完成）
我们的做法是，将复杂对象的构建和表示相分离，使得同样的构建过程（step1，step2，step3）可以创建不同的变化。
这里以造房子举例，假设造房子都有3步，floor，upstairs和elec，我们把他们定义为step1，2，3，在派生类中我们只重写step1，step2，step3，而放在基类中的构建流程确是不变（稳定）的。
ps1：至于为什么不在父类的构造函数中使用子类的虚函数达到多态构造的效果，是因为c++不支持，C++如果在构造函数中使用虚函数，那么实现的是一个静态绑定，根本不会调用子类实现的虚函数，因为c++在构造派生类对象的时候是先调用父类的构造函数，如果父类的构造函数中有子类的virtual_func，而这时候子类还没有完成构造，就寄了。
ps2：我直接把构造的整体流程放builder里的create_house函数里了。其实放在director类里面也可以，就跟上面说的写法一样，把整体的流程单独拿出来。

#pragma once
#include <iostream>
using namespace std;
template<typename T>
class floor_base {

};

template<typename T>
class upstairs_base {

};

template<typename T>
class elec_base {

};

template<typename T>
class strone_floor :public floor_base<T> {

};

template<typename T>
class strone_upstairs :public upstairs_base<T> {

};

template<typename T>
class strone_elec :public elec_base<T> {

};

template<typename T>
class tree_floor :public floor_base<T> {

};

template<typename T>
class tree_upstairs :public upstairs_base<T> {

};

template<typename T>
class tree_elec :public elec_base<T> {

};


template<typename T>
class House_base {
public :
	floor_base<T>* floor;
	upstairs_base<T>* upstairs;
	elec_base<T>* elec;
};



template<typename T>
class House_builder_base {
public:
	House_base<T>* GetResult() {
		return M_house;
	}
	void create_house() {
		M_house = new House_base<T>;
		M_house->floor = step1();
		M_house->upstairs = step2();
		M_house->elec = step3();
	}
	virtual floor_base<T>* step1()=0;
	virtual upstairs_base<T>* step2()=0;
	virtual elec_base<T>* step3()=0;
protected:
	House_base<T>* M_house;
};

template<typename T>
class strone_house_builder :public House_builder_base<T> {
public:
	virtual floor_base<T>* step1() {
		cout << "石头屋步骤1" << endl;
		return new  strone_floor<T>;
	}
	virtual upstairs_base<T>* step2() {
		cout << "石头屋步骤2" << endl;
		return new  strone_upstairs<T>;
	}
	virtual elec_base<T>* step3() {
		cout << "石头屋步骤3" << endl;
		return new  strone_elec<T>;
	}
};

template<typename T>
class tree_house_builder :public House_builder_base <T> {
public:
	virtual floor_base<T>* step1() {
		cout << "树屋步骤1" << endl;
		return new  tree_floor<T>;
	}
	virtual upstairs_base<T>* step2() {
		cout << "树屋步骤2" << endl;
		return new  tree_upstairs<T>;
	}
	virtual elec_base<T>* step3() {
		cout << "树屋步骤3" << endl;
		return new  tree_elec<T>;
	}
};

template<typename T>
class Director {
public:
	Director(House_builder_base<T>* hou) :house(hou) {}
	void create_a_house() {
		house->create_house();
		House_base<T>* true_house = house->GetResult();
	}
protected:
	House_builder_base<T>* house;
};

测试

	//测试builder模式
	cout << "测试builder模式" << endl;
	auto tree_builder = new tree_house_builder<bool>;
	auto director = new Director<bool>(tree_builder);
	director->create_a_house();//这个时候一个house_base对象就已经放在这个director对象里了