建造者模式

建造者模式（Builder），将一个一个复杂对象的构建与它的表现分离，使得同样的构建过程可以创建不同的对象。
举例：画一个小人，需要画头、身体、左手、右手、左脚和右脚。我们先定义一个抽象的建造人的类，来把这个过程给稳定住，不让任何人遗忘其中的任何一步。
当我们需要画一个瘦小人和一个胖小人的时候，我们还需要建造者模式中的一个很重要的类，指挥者（Director）来控制建造过程，也用它来隔离用户与建造过程的关联。

personBuilder.h

#pragma once

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

	virtual void BuildHead() = 0;	  //画头部
	virtual void BuildBody() = 0;     //画身体
	virtual void BuildArmLeft() = 0;  //画左手
	virtual void BuildArmRight() = 0; //画右手
	virtual void BuildLegLeft() = 0;  //画左脚
	virtual void BuildLegRight() = 0; //画右脚
};

personThinBuilder.h

#pragma once

#include "personBuilder.h"
#include <iostream>

class PersonThinBuilder : public PersonBuilder
{
	void BuildHead() override
	{
		std::cout << "画瘦小人的头部" << std::endl;
	}
	void BuildBody() override
	{
		std::cout << "画瘦小人的身体" << std::endl;
	}
	void BuildArmLeft() override
	{
		std::cout << "画瘦小人的左胳膊" << std::endl;
	}
	void BuildArmRight() override
	{
		std::cout << "画瘦小人的右胳膊" << std::endl;
	}
	void BuildLegLeft() override
	{
		std::cout << "画瘦小人的左腿" << std::endl;
	}
	void BuildLegRight() override
	{
		std::cout << "画瘦小人的右腿" << std::endl;
	}
};

personFatBuilder.h

#pragma once

#include "personBuilder.h"
#include <iostream>

class PersonFatBuilder : public PersonBuilder
{
	void BuildHead() override
	{
		std::cout << "画胖小人的头部" << std::endl;
	}
	void BuildBody() override
	{
		std::cout << "画胖小人的身体" << std::endl;
	}
	void BuildArmLeft() override
	{
		std::cout << "画胖小人的左胳膊" << std::endl;
	}
	void BuildArmRight() override
	{
		std::cout << "画胖小人的右胳膊" << std::endl;
	}
	void BuildLegLeft() override
	{
		std::cout << "画胖小人的左腿" << std::endl;
	}
	void BuildLegRight() override
	{
		std::cout << "画胖小人的右腿" << std::endl;
	}
};

personDirector.h

#pragma once

#include "personBuilder.h"

class PersonDirector
{
public:
	PersonDirector(PersonBuilder *person) : m_person(person) {}
	void CreatePerson()
	{
		m_person->BuildHead();
		m_person->BuildBody();
		m_person->BuildArmLeft();
		m_person->BuildArmRight();
		m_person->BuildLegLeft();
		m_person->BuildLegRight();
	}

private:
	PersonBuilder *m_person;
};

客户端main.cpp

#include "personDirector.h"
#include "personThinBuilder.h"
#include "personFatBuilder.h"

int main()
{
	PersonBuilder *thinBuilder = new PersonThinBuilder();
	PersonDirector *thinDirector = new PersonDirector(thinBuilder);
	thinDirector->CreatePerson();

	std::cout << std::endl;
	PersonBuilder *fatBuilder = new PersonFatBuilder();
	PersonDirector *fatDirector = new PersonDirector(fatBuilder);
	fatDirector->CreatePerson();

	delete thinBuilder;
	delete thinDirector;
	delete fatBuilder;
	delete fatDirector;

	getchar();
	return 0;
}

运行结果：

画瘦小人的头部
画瘦小人的身体
画瘦小人的左胳膊
画瘦小人的右胳膊
画瘦小人的左腿
画瘦小人的右腿

画胖小人的头部
画胖小人的身体
画胖小人的左胳膊
画胖小人的右胳膊
画胖小人的左腿
画胖小人的右腿

product.h

#pragma once

#include <string>
#include <list>
#include <iostream>

class Product
{
public:
	void Add(const std::string &part)
	{
		m_patrs.push_back(part);
	}

	void Show()
	{
		std::cout << std::endl << "产品 创建 ---";
		for (const auto &part : m_patrs)
		{
			std::cout << part;
		}
	}

private:
	std::list<std::string> m_patrs;
};

builder.h

#pragma once

class Product;

class Builder
{
public:
	virtual ~Builder() {}
	virtual void BuildPartA() = 0;
	virtual void BuildPartB() = 0;
	virtual Product *GetResult() = 0;
};

concreteBuilder1.h

#pragma once

#include "builder.h"
#include "product.h"

class ConcreteBuilder1 : public Builder
{
public:
	ConcreteBuilder1() : m_product(new Product()) {}
	~ConcreteBuilder1()
	{
		delete m_product;
	}

	void BuildPartA() override
	{
		m_product->Add("部件A");
	}

	void BuildPartB() override
	{
		m_product->Add("部件B");
	}

	Product * GetResult() override
	{
		return m_product;
	}

private:
	Product *m_product;
};

concreteBuilder2.h

#pragma once

#include "builder.h"
#include "product.h"

class ConcreteBuilder2 : public Builder
{
public:
	ConcreteBuilder2() : m_product(new Product()) {}
	~ConcreteBuilder2()
	{
		delete m_product;
	}

	void BuildPartA() override
	{
		m_product->Add("部件X");
	}

	void BuildPartB() override
	{
		m_product->Add("部件Y");
	}

	Product * GetResult() override
	{
		return m_product;
	}

private:
	Product *m_product;
};

director.h

#pragma once

#include "builder.h"

class Director
{
public:
	void Construct(Builder * builder)
	{
		builder->BuildPartA();
		builder->BuildPartB();
	}
};

客户端main.cpp

#include "concreteBuilder1.h"
#include "concreteBuilder2.h"
#include "director.h"

int main()
{
	Director *director = new Director();
	Builder *b1 = new ConcreteBuilder1();
	Builder *b2 = new ConcreteBuilder2();

	director->Construct(b1);
	Product *p1 = b1->GetResult();
	p1->Show();

	director->Construct(b2);
	Product *p2 = b2->GetResult();
	p2->Show();

	delete director;
	delete b1;
	delete b2;

	getchar();
	return 0;
}

运行结果：

产品 创建 ---部件A部件B
产品 创建 ---部件X部件Y