Builder

//建造者模式
//定义
//将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。
//实用范围
//1 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
//2 当构造过程必须允许被构造的对象有不同表示时。
//角色
//在这样的设计模式中，有以下几个角色：
//1 builder：为创建一个产品对象的各个部件指定抽象接口。
//2 ConcreteBuilder：实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并 提供一个检索产品的接口。
//3 Director：构造一个使用Builder接口的对象。
//4 Product：表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。
#include <stdio.h>
#include <string>
using namespace std;
//将组件组装成一个产品 并向外提供成品

/简单的建造者(仅一个建造者)///
class Product_2 //只需要提供一个产品图 各个零件可以外部建造
{
public:
 string PartA,PartB,PartC;//为简单 这里的组件设置为3个字符串 其实可以是成员函数等
 void show()
 { //由于printf是c的函数 不支持扩展的string类型（string本质是类而非字符串类型）
  printf("%s,%s,%s\n",PartA.c_str(),PartA.c_str(),PartA.c_str());
 }
protected:
private: 
};

class ConcreateBuilder_2
{
public:
 const string& BuildPartA(const string& buildPara){return buildPara;}
 const string& BuildPartB(const string& buildPara){return buildPara;}
 const string& BuildPartC(const string& buildPara){return buildPara;}

 Product_2* GetProduct(const string& buildParaA,const string& buildParaB,const string& buildParaC)
 {
  Product_2* product = new Product_2();
  product->PartA = BuildPartA(buildParaA);
  product->PartB = BuildPartB(buildParaB);
  product->PartC = BuildPartC(buildParaC);

  return product;
 }
protected:
private:
};

void Builder_test2()
{
 Product_2* product = (new ConcreateBuilder_2)->GetProduct("建造ParaA","建造ParaB","建造ParaC");
 product->show();
}

/(完整建造者)/
class Product
{
public:
 Product(){}
 ~Product(){}
 string PartA,PartB,PartC;//为简单 这里的组件设置为3个字符串 其实可以是成员函数等
 
 void show()
 {
  //由于printf是c的函数 不支持扩展的string类型（string本质是类而非字符串类型）
  printf("%s,%s,%s\n",PartA.c_str(),PartA.c_str(),PartA.c_str());
 }
protected:
private: 
};

class Builder//如果系统中只需要一个具体的建造者的话，可以省略掉抽象建造者。
{
public:
 virtual ~Builder(){}

 virtual const string& BuildPartA(const string& buildPara) = 0;
 virtual const string& BuildPartB(const string& buildPara) = 0;
 virtual const string& BuildPartC(const string& buildPara) = 0;
 
 virtual Product* GetProduct(const string& buildParaA,const string& buildParaB,const string& buildParaC) = 0;
protected:
 Builder(){}//不能在类外被直接new出实例  可以在子类调用 如果私有子类的也无法实例了（构造函数 先调用的是基类的构造 在构造自身 析构相反）
private:
};

class ConcreateBuilder:public Builder
{
public:
 ConcreateBuilder(){}
 ~ConcreateBuilder(){}

 const string& BuildPartA(const string& buildPara)
 {
  return buildPara;
 }
 const string& BuildPartB(const string& buildPara)
 {
  return buildPara;
 }
 const string& BuildPartC(const string& buildPara) 
 {
  return buildPara;
 }

 Product* GetProduct(const string& buildParaA,const string& buildParaB,const string& buildParaC)
 {
  Product* product = new Product();
  product->PartA = BuildPartA(buildParaA);
  product->PartB = BuildPartB(buildParaB);
  product->PartC = BuildPartC(buildParaC);

  return product;
 }
protected:
private:
};

//在具体建造者只有一个的情况下，如果抽象建造者角色已经被省略掉，那么还可以省略掉指导者角色，让Builder自己扮演指导者和建造者双重角色。
class Director
{
public:
 Director(Builder* bld)
 {
  _bld = bld;
 }
 ~Director(){}
 Builder* getBld()
 {
  return _bld;
 }
protected:
private:
 Builder* _bld;
};

void Builder_test()
{
 Director* d = new Director(new ConcreateBuilder());

 Product* product = d->getBld()->GetProduct("建造ParaA","建造ParaB","建造ParaC");
 product->show();
}