建造者模式——探索之旅

,建造者模式(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);
}