设计模式之抽象工厂模式

抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。抽象工厂允许客户利用抽象的接口产生一组相关的产品，具体的产品通常也是由继承自抽象工厂的具体工厂决定。抽象工厂的类图如下：

在抽象工厂提供了一个产生一组相关产品的接口，而对于这组相关产品，每个具体工厂都会有自己不同的实现。客户可以在自己的类中加入一个抽象工厂的指针或引用，然后将它传入一些针对抽象工厂所写的代码中，这样也能让客户从具体的产品对象中解耦，即做到依赖抽象不依赖具体。

下面是一个利用抽象工厂模式设计的具体例子：

具体程序如下：为了做到精简，程序中只实现了一个具体工厂NYPizzaIngredientFactory，原料也没有全都写出来。

#include "stdafx.h"
#include <iostream>
#include <string>
#include <memory>
using namespace std;

//抽象原料
 class Dough {
 public:
	virtual string toString()=0;
};
 class Sauce {
 public:
	 virtual string toString()=0;
 };
 class Cheese {
 public:
	 virtual string toString()=0;
 };

 class Clams  {
 public:
	 virtual string toString()=0;
 };
 //具体原料
 class ThickCrustDough :public Dough {
 public:
	 string toString() {
		 return "ThickCrust style extra thick crust dough";
	 }
 };
 class MarinaraSauce  :public Sauce  {
 public:
	 string toString() {
		 return "Marinara Sauce";
	 }
 };
 class ReggianoCheese  :public Cheese  {
 public:
	 string toString() {
		 return "Reggiano Cheese";
	 }
 };

 class FreshClams   :public Clams  {
 public:
	 string toString() {
		 return "Fresh Clams from Long Island Sound ";
	 }
 };

//抽象原料工厂，生产产品需要的所有原料，所有的具体工厂必须继承自该工厂
class PizzaIngredientFactory {

public :
	virtual shared_ptr<Dough>  createDough()=0;
	virtual shared_ptr<Sauce> createSauce()=0;
	virtual shared_ptr<Cheese> createCheese()=0;
	virtual shared_ptr<Clams> createClam()=0;

};
//具体原料工厂
 class NYPizzaIngredientFactory :public PizzaIngredientFactory {

 public:
	 shared_ptr<Dough> createDough() {
		return shared_ptr<Dough>(new ThickCrustDough) ;
	}

	shared_ptr<Sauce>  createSauce() {
		return shared_ptr<Sauce>(new MarinaraSauce);
	}

	shared_ptr<Cheese> createCheese() {
		return shared_ptr<Cheese>(new ReggianoCheese);
	}
	shared_ptr<Clams> createClam() {
		return shared_ptr<Clams>(new FreshClams);
	}
};


 //抽象产品(由抽象原料工厂的原料组成)
 class Pizza {
 public:
	 string name;
	 shared_ptr<Dough> dough;
	 shared_ptr<Sauce> sauce;
	 shared_ptr<Cheese> cheese;
	 shared_ptr<Clams> clam;
	 virtual void prepare()=0;

	 void bake()
	 {
		 cout<<"Bake for 25 minutes at 350"<<endl;
	 }
	 void cut()
	 {
		 cout<<"Cutting the pizza into diagonal slices"<<endl;
	 }
	 void box()
	 {
		 cout<<"Place pizza in official PizzaStore box"<<endl;
	 }

	 void setName(string name) {
		 this->name = name;
	 }

	 string getName() {
		 return name;
	 }
 };

//具体产品
class CheesePizza :public Pizza {
	
private:
	shared_ptr<PizzaIngredientFactory> ingredientFactory;
public:
	 CheesePizza(shared_ptr<PizzaIngredientFactory> ingredientFactory) {
		this->ingredientFactory=ingredientFactory;
	}

	void prepare() {
		cout<<"Preparing " <<name;
		dough = ingredientFactory->createDough();
		sauce = ingredientFactory->createSauce();
		cheese = ingredientFactory->createCheese();
		clam=   ingredientFactory->createClam();
	}
};
//具体产品
 class ClamPizza :public Pizza {
 private:
	shared_ptr<PizzaIngredientFactory> ingredientFactory;
 public:
	ClamPizza(shared_ptr<PizzaIngredientFactory> ingredientFactory) {
		this->ingredientFactory=ingredientFactory;
	}

	void prepare() {
		cout<<"Preparing " <<name;
		dough = ingredientFactory->createDough();
		sauce = ingredientFactory->createSauce();
		cheese = ingredientFactory->createCheese();
		clam = ingredientFactory->createClam();
	}
};

class PizzaStore
{
public:
	shared_ptr<Pizza> orderPizza(string type)  
	{
		shared_ptr<Pizza> pizza;        
		pizza=createPizza(type);    //使用工厂方法生成的产品，并不在乎具体产品是什么
		pizza->prepare();
		pizza->bake();
		pizza->cut();
		pizza->box();
		return pizza;
	}
protected:
	virtual shared_ptr<Pizza> createPizza(string type)=0;   //生成产品的方法(抽象工厂与工厂方法的不同主要体现在这个方法中)
};

class NYPizzaStore :public PizzaStore {

protected :
	shared_ptr<Pizza> createPizza(string item) {
		shared_ptr<Pizza> pizza=nullptr;
		shared_ptr<PizzaIngredientFactory> ingredientFactory = 
			shared_ptr<PizzaIngredientFactory>(new NYPizzaIngredientFactory());

		if (item.compare("cheese")==0) {

			pizza = shared_ptr<Pizza>(new CheesePizza(ingredientFactory));
			pizza->setName("New York Style Cheese Pizza");
		}
		else if (item.compare("clam")==0) 
		{
			pizza = shared_ptr<Pizza>(new ClamPizza(ingredientFactory));
			pizza->setName("New York Style Clam Pizza");

		}
		else
			pizza= nullptr;
		return pizza;
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	shared_ptr<PizzaStore> nyPizzaStore=shared_ptr<PizzaStore>(new NYPizzaStore);
	shared_ptr<Pizza>pizza= nyPizzaStore->orderPizza("cheese");
	cout<<"I order a "<<pizza->getName()<<endl;

	shared_ptr<Pizza> pizza1=nyPizzaStore->orderPizza("clam");
	cout<<"Xiaoming order a "<<pizza1->getName()<<endl;
	return 0;
}

程序运行结果如下：

程序中，