【C++设计模式】建造者模式

#ifndef __BUILDER_H__
#define __BUILDER_H__

#include <string>

//【说明】
// 一个复杂对象的创建，其通常是由很多的子对象构成；建造者模式就提供了一种“封装机制”来将各个对象的变化隔离开，最终，组合成复杂对象的过程是不会变的。

//【定义】
// 建造者模式：将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

//【角色】
// 1) 抽象建造者（Builder）：给出一个抽象接口，规范建造者对于生产的产品的各个组成部分的建造。
// 2) 具体建造者（ConcreteBuilder）：实现builder接口，针对不同的商业逻辑，具体化各对象部分的建造，最后返回一个建造好的产品。
// 3) 导演（Director）：导演，顾名思义，负责规范流程之用。在指导中不涉及产品的创建，只负责保证复杂对象各部分被创建或按某种顺序创建。
// 4) 产品（Product）：复杂对象。

//【意义】
// 使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在导演类中对整体而言可以取得比较好的稳定性。
// 建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险。
// 导演并不知道自己使用的究竟是builder的哪个子类，只有不知道，子类才能替换，正是因为可替换，组件才有价值。

//【示例】：

//要建造的对象
class Computer
{
public:	
	void SetFactory(const std::string &factory);

	void SetCpu(const std::string &cpu);

	void SetMemory(int memory);

	void SetColor(const std::string &color);

	void Show();

private:
	std::string m_factory;
	std::string m_cpu;
	int         m_memory;
	std::string m_color;	
};

//构建者接口
class iComputerBuilder
{
public:
	iComputerBuilder(){ }

	virtual ~iComputerBuilder(){ }

	virtual void BuildFactory(const std::string &factory) = 0;

	virtual void BuildCpu(const std::string &cpu) = 0;

	virtual void BuildMemory(int memory) = 0;

	virtual void BuildColor(const std::string &color) = 0;	

	virtual Computer * GetComputer() = 0;

};

class ConcreteComputerBuilder : public iComputerBuilder
{
public:
	ConcreteComputerBuilder();

	~ConcreteComputerBuilder();

	virtual void BuildFactory(const std::string &factory);

	virtual void BuildCpu(const std::string &cpu);

	virtual void BuildMemory(int memory);

	virtual void BuildColor(const std::string &color);	

	virtual Computer * GetComputer();

private:
	Computer * m_computer;
};

class ComputerDirector
{
public:	

	void Construct(iComputerBuilder * builder);
};

void TestBuilder();


#endif

#include "AbstractFactory.h"

void ChinaProductA::PrintProductA()
{
	printf("Print ChinaProductA. \n");
}

void ChinaProductB::PrintProductB()
{
	printf("Print ChinaProductB. \n");
}

void AmericaProductA::PrintProductA()
{
	printf("Print AmericaProductA. \n");
}

void AmericaProductB::PrintProductB()
{
	printf("Print AmericaProductB. \n");
}

iProductA* ChinaFactory::CreateProductA()
{
	return new ChinaProductA();
}

iProductB* ChinaFactory::CreateProductB()
{
	return new ChinaProductB();
}

iProductA* AmericaFactory::CreateProductA()
{
	return new AmericaProductA();
}

iProductB* AmericaFactory::CreateProductB()
{
	return new AmericaProductB();
}

void TestAbstractFactory()
{
	iAbstractFactory *cf = new ChinaFactory();

	iProductA *ca = cf->CreateProductA();

	iProductB *cb = cf->CreateProductB();

	ca->PrintProductA();

	cb->PrintProductB();

	delete cf; 
	delete ca;
	delete cb;

	iAbstractFactory * af = new AmericaFactory();

	iProductA *aa = af->CreateProductA();

	iProductB *ab = af->CreateProductB();

	aa->PrintProductA();

	ab->PrintProductB();

	delete af; 
	delete aa;
	delete ab;
}