C++建造者模式

简介

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

代码

#include<iostream>
using namespace std;
#include<list>
//Prodect是具体的产品
class Prodect
{
private:
	list<string> m_lst;
public:
	void show()
	{
		auto ite = m_lst.begin();
		while(ite!=m_lst.end())
		{
			cout<<(*ite).c_str()<<endl;
			++ite;
		}
	}
	void add(string str)
	{
		m_lst.push_back(str);
	}
};
//抽象类
class Builder
{
public:
	virtual void BuildPartA()=0;
	virtual void BuildPartB()=0;
	virtual Prodect *GetResult()=0;
};
//抽象类子类，其内部有具体的实施步骤
class ConcreteBuilder1:public Builder
{
public:
	ConcreteBuilder1()
	{
		prodect = new Prodect();
	}
	void BuildPartA()
	{
		prodect->add("部件1-A");
	}
	void BuildPartB()
	{
		prodect->add("部件1-B");
	}
	Prodect *GetResult()
	{
		return prodect;
	}
private:
	Prodect *prodect;
};
//抽象类子类，其内部有具体的实施步骤
class ConcreteBuilder2:public Builder
{
public:
	ConcreteBuilder2()
	{
		prodect = new Prodect();
	}
	void BuildPartA()
	{
		prodect->add("部件2-A");
	}
	void BuildPartB()
	{
		prodect->add("部件2-B");
	}
	Prodect *GetResult()
	{
		return prodect;
	}
private:
	Prodect *prodect;
};
//指挥者 通过传入的抽象子类进行具体的实施
class Director
{
public:
	void Construct(Builder *build)
	{
		build->BuildPartA();
		build->BuildPartB();
	}
};

int main()
{
	Director dir;
	Builder *build1 = new ConcreteBuilder1();
	Builder *build2 = new ConcreteBuilder2();
	dir.Construct(build1);
	Prodect *p1 = build1->GetResult();
	p1->show();

	system("pause");
	return 0;
}

优点

建造者build独立于其他类，易扩展

缺点

1、产品必须有共同点，范围有限制
2、内部复杂，有很多的建造类

使用场景

1、需要生成的对象具有复杂的内部结构
2、需要生成的对象内部属性本身相互依赖