建造者模式——探索之旅

,建造者模式(Builder Pattern)，将一个复杂对象的构建与它的表示分离，使的同样的构建过程可以创建不同的表示。建造者模式的本质是使组装过程（用指挥者类进行封装，从而达到解耦的目的）和创建具体产品解耦,使我们不用去关心每个组件是如何组装的。

#pragma once

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

struct IProductPart
{

};

class ProductPartA :public IProductPart
{
public:
ProductPartA()
{
cout << "build ProductPartA" << endl;
}
virtual ~ProductPartA(){}

void functionA()
{
cout << "enter functionA" << endl;
}
};

class ProductPartB :public IProductPart
{
public:
ProductPartB()
{
cout << "build ProductPartB" << endl;
}
virtual ~ProductPartB(){}

void functionB()
{
cout << "enter functionB" << endl;
}
};

class ProductPartC :public IProductPart
{
public:
ProductPartC()
{
cout << "build ProductPartC" << endl;
}
virtual ~ProductPartC(){}

void functionC()
{
cout << "enter functionC" << endl;
}
};

class Product
{
public:
Product()
{
_productList.clear();
}
virtual ~Product(){}

void add(IProductPart* part)
{
_productList.push_back(part);
}
private:
list<IProductPart*> _productList;
};

class Builder
{
public:
Builder()
{
_product = new Product;
}
virtual ~Builder(){}

virtual void buildPart() = 0;
virtual Product* getResult(){ return nullptr; }
protected:
template<typename T>
void _buildPart()
{
IProductPart* productPart = new T;
_product->add(productPart);
}

Product* _product;
};

class ConcreteBuilder:public Builder
{
public:
ConcreteBuilder(){}
virtual ~ConcreteBuilder(){}

virtual void buildPart()
{
_buildPart<ProductPartA>();
_buildPart<ProductPartB>();
_buildPart<ProductPartC>();
}
virtual Product* getResult()
{
return _product;
}
};

class Director
{
public:
Director(){}
virtual ~Director(){}

void Construct(Builder* builder)
{
builder->buildPart();
}
virtual Product* getResult(Builder* builder)
{
return builder->getResult();
}
};

void builderTest()
{
Builder* builder = new ConcreteBuilder;
Director* director = new Director;
director->Construct(builder);
director->getResult(builder);
}