设计模式——建造者模式（C++实现）

1、建造者模式简介

1.           使用多个简单的对象 一步步构建一个复杂的对象，将对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。属于创建型模式。
2. 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时，或者当构造过程必须允许被构造的对象有不同的表示时，可以使用建造者模式构造对象。

借鉴菜鸟教程里面的建造者模式的例子，这里用C++实现：

#include<iostream>
#include<string>
#include<vector>

using namespace std;

//声明食物包装接口
class package;

//创建一个表示食物条目的抽象基类接口
class Item
{
public:
	Item() {};
	virtual ~Item();
	virtual string name(void)=0;    //返回食物的名字
	virtual package *pack(void)=0;  //返回食物的包装方式
	virtual float price(void)=0;    //返回食物的价格

protected:
	string it_name;   //食物的名字
	package *tpack;   //食物的包装方式
	float it_price;   //食物的价格
};

Item::~Item()
{
	delete tpack;
	tpack = NULL;
}

//创建一个表示食物包装的抽象基类接口
class package
{
public:
	package() {};
	virtual ~package() {};
	virtual string pack_way(void)=0;

};



//创建一个纸包装的类继承包装抽象基类
class Wrapper :public package
{
public:
	Wrapper() {};
	~Wrapper() {};
	string pack_way(void);
};

string Wrapper::pack_way(void)
{
	return "Wrapper pack way";
}

//创建一个瓶子包装的类继承包装抽象基类
class Bottle : public package
{
public:
	Bottle() {};
	~Bottle() {};
	string pack_way(void);
};

string Bottle::pack_way(void)
{
	return "Bottle pack way";
}

//创建素食汉堡继承食物条目抽象基类
class VegBurger : public Item
{
public:
	VegBurger();
	~VegBurger() {};
	float price(void);
	string name(void);
	package *pack(void);
};

VegBurger::VegBurger()
{
	it_name = "VegBurger";
	it_price = 23.5;
	tpack = (package*)new Wrapper();
}

string VegBurger::name(void)
{
	return it_name;
}

float VegBurger::price(void)
{
	return it_price;
}

package *VegBurger::pack(void)
{
	return tpack;
}

//创建素食汉堡继承食物条目抽象基类
class chickenBurger :public Item
{
public:
	chickenBurger();
	~chickenBurger();
	float price(void);
	string name(void);
	package *pack(void);
};

chickenBurger::chickenBurger()
{
	it_name = "chickenBurger";
	it_price = 23.5;
	tpack = (package*)new Wrapper();
}

chickenBurger::~chickenBurger()
{
}

string chickenBurger::name(void)
{
	return it_name;
}

float chickenBurger::price(void)
{
	return it_price;
}

package *chickenBurger::pack(void)
{
	return tpack;
}

//创建可口可乐继承食物条目抽象基类
class Coke :public Item
{
public:
	Coke();
	~Coke();
	float price(void);
	string name(void);
	package *pack(void);
};

Coke::Coke()
{
	it_name = "Coke";
	it_price = 23.5;
	tpack = (package*)new Bottle();
}

Coke::~Coke()
{
}

string Coke::name(void)
{
	return it_name;
}

float Coke::price(void)
{
	return it_price;
}

package *Coke::pack(void)
{
	return tpack;
}

//创建百事可乐继承食物条目抽象基类
class Pepsi :public Item
{
public:
	Pepsi();
	~Pepsi();
	float price(void);
	string name(void);
	package *pack(void);
};

Pepsi::Pepsi()
{
	it_name = "Pepsi";
	it_price = 23.5;
	tpack = (package*)new Bottle();
}

Pepsi::~Pepsi()
{

}

string Pepsi::name(void)
{
	return it_name;
}

float Pepsi::price(void)
{
	return it_price;
}

package *Pepsi::pack(void)
{
	return tpack;
}

//创建一个meal类，是一个套餐的组合
class meal
{
public:
	meal() {};
	~meal();

	void add_item(Item *it);

	void show_item(void);

private:
	vector<Item*> meal_list;
};

meal::~meal()
{
	vector<Item*>::iterator it;
	for (it= meal_list.begin(); it!=meal_list.end(); it++)
	{
		delete (*it);
		(*it) = NULL;
	}
	cout << "delete meal class" << endl;
}

void meal::add_item(Item *it)
{
	meal_list.push_back(it);
}

void meal::show_item(void)
{
	vector<Item*>::iterator it;
	for (it = meal_list.begin(); it != meal_list.end(); it++)
	{
		cout << "name: " << (*it)->name() << endl;
		cout << "price: " << (*it)->price() << endl;
		cout << "pack: " << (*it)->pack()->pack_way() << endl;
		cout << endl;
	}
}

//主函数
int main()
{
	meal t1;
	t1.add_item((Item*)new VegBurger());
	t1.add_item((Item*)new chickenBurger());
	t1.add_item((Item*)new Coke());
	t1.add_item((Item*)new Pepsi());

	t1.show_item();

	system("pause");
	return 0;
}

采用visual studio 2015运行结果如下：