問題需求與工廠模式一樣，用到了抽象工廠模式----提供一個介面，用於建立相關或依賴物件的家族，而不需要制定具體的類。允許客戶使用抽象的介面來建立一組相關的產品，而不需要知道或關心實際產出的具體產品是什麼。實現客戶和具體產品的解耦。即是披薩店和具體的披薩工廠解耦，用一個抽象類原料工廠實現產品的例項化。

抽象原料工廠類

/******************************/
/*原料工廠*/
/*****************************/
#ifndef INGREDIENTFACTORY_H_
#define INGREDIENTFACTORY_H_
#include<iostream>
#include<string>
#include<vector>

using namespace std;

//抽象工廠介面類
class IngredientFactory{
public:
	virtual string createDough() = 0;
	virtual string createSauce() = 0;
	virtual string createCheese() = 0;
	virtual vector<std::string> createVeggies() = 0;
	virtual string createPepperoni() = 0;
	virtual string createClam() = 0;
};

class NYIngredientFactory:public IngredientFactory{
public:
	std::string createDough(){
		cout << "製作薄的硬殼麵糰" << endl;
		return "Thin Crust Dough";
	}
	std::string createSauce(){
		cout << "製作Marinara醬汁" << endl;
		return "Marinara Sauce";
	}
	std::string createCheese(){
		cout << "製作Reggiano乳酪" << endl;
		return "Reggiano Cheese";
	}
	std::vector<std::string> createVeggies(){
		std::vector<std::string> temp;
		temp.push_back("Garlic");
		temp.push_back("Onion");
		temp.push_back("Mushroom");
		temp.push_back("Redpepper");
		cout << "新增蔬菜-洋蔥，蘑菇，紅辣椒" << endl;
		return temp;
	}
	std::string createPepperoni(){
		cout << "製作辣椒絲" << endl;
		return "Sliced Pepperoni";
	}
	std::string createClam(){
		cout << "清洗蛤蜊" << endl;
		return "Fresh Clams";
	}
};

#endif
 

#ifndef PIZZA_H_
#define PIZZA_H_
#include<string>
#include<iostream>
#include"IngredientFactory.h"

using namespace std;

class Pizza{
private:
	string name;
	string dough;
	string sauce;
	vector<string> veggies;
	string cheese;
	string pepperoni;
	string clam;
public:
	Pizza(){}
	virtual ~Pizza(){}
	void setName(string& temp){
		name = temp;
	}
	void setDough(string& temp){
		dough = temp;
	}
	void setSauce(string& temp){
		sauce = temp;
	}
	void setVeggies(vector<string>& temp){
		veggies = temp;
	}
	void setCheese(string& temp){
		cheese = temp;
	}
	void setPepperoni(string& temp){
		pepperoni = temp;
	}
	void setClam(string& temp){
		clam = temp;
	}
	virtual void prepare()=0;
	virtual void bake(){
		cout << "在350度烘烤25分鐘" << endl;
	}
	virtual void cut(){
		cout << "切成斜片" << endl;
	}
	virtual void box(){
		cout << "用正規包裝袋" << endl;
	}
	virtual string getName(){
		return name;
	}

};

class CheesePizza :public Pizza{
public:
	CheesePizza(IngredientFactory* temp_factory){
		factory = temp_factory;
	}
	void prepare(){
		cout << "正在準備" << getName() << endl;
		setDough(factory->createDough());
		setSauce(factory->createSauce());
		setCheese(factory->createCheese());
	}
private:
	IngredientFactory* factory;
};

class ClamPizza :public Pizza{
public:
	ClamPizza(IngredientFactory* temp_factory){
		factory = temp_factory;
	}
	void prepare(){
		cout << "正在準備" << getName() << endl;
		setDough(factory->createDough());
		setSauce(factory->createSauce());
		setCheese(factory->createCheese());
		setClam(factory->createClam());
	}
private:
	IngredientFactory* factory;
};

#endif
 

#ifndef PIZZASTORE_H_
#define PIZZASTORE_H_
#include"pizza.h"
enum PizzaType{ cheese = 0, pepperoni, clam, veggie };//Pizaa型別
class PizzaStore{
public:
	Pizza* orderPizza(PizzaType type){
		Pizza* temp_pizza;
		temp_pizza = createPizza(type);

		temp_pizza->prepare();
		temp_pizza->bake();
		temp_pizza->cut();
		temp_pizza->box();
		 
		return temp_pizza;
	}
	virtual Pizza* createPizza(PizzaType type) = 0;
};

class NYPizzaStore :public PizzaStore{
public:
	Pizza* createPizza(PizzaType type){
		Pizza *pizza = NULL;
		IngredientFactory* InFactory = new NYIngredientFactory();
		string str;
		switch (type)
		{
		case cheese:
			pizza = new CheesePizza(InFactory);
			str = "紐約風味奶油披薩";
			pizza->setName(str);
			break;
		case clam:
			pizza = new ClamPizza(InFactory);
			str = "紐約風味蛤蜊披薩";
			pizza->setName(str);
			break;
		/*case cheese:
			pizza = new NYStyleCheesePizza();
			break;*/
		default:
			std::cout << "There is not this type of pizze" << std::endl;
		}
		return pizza;
	}
};

//class ChicagoPizzaStore :public PizzaStore{
//public:
//	Pizza* createPizza(PizzaType type){
//		Pizza *pizza = new Pizza;
//		switch (type)
//		{
//		case cheese:
//			pizza = new ChicagoStyleCheesePizza();
//			break;
//			/*case cheese:
//			pizza = new NYStyleCheesePizza();
//			break;
//			case cheese:
//			pizza = new NYStyleCheesePizza();
//			break;*/
//		default:
//			std::cout << "There is not this type of pizze" << std::endl;
//		}
//		return pizza;
//	}
//};
#endif
 

#include"IngredientFactory.h"
#include"Pizza.h"
#include"PizzaStore.h"

int main()
{
	cout << "-----小明的訂單-----" << endl;
	PizzaStore* nyPizzaStore = new NYPizzaStore();
	nyPizzaStore->orderPizza(cheese);
	nyPizzaStore->createPizza(cheese);
	cout << endl;
	cout << endl;
	cout << "-----小紅的訂單-----" << endl;
	//PizzaStore* nyPizzaStore = new NYPizzaStore();
	nyPizzaStore->orderPizza(clam);
	nyPizzaStore->createPizza(clam);

	return 0;
}

工廠方法和抽象工廠方法都是負責建立物件，工廠方法是利用繼承建立，抽象工廠方法是利用的物件組合。

工廠方法通過子類建立物件，客戶只需知道他們所使用的抽象型別就可以然後由子類負責決定具體型別，實現了客戶和具體型別中解耦。

抽象工廠方法提供一個用來建立產品家族的抽象型別，這個型別的子類定義了產品被產生的方法。要想使用這個工廠，必須要先例項化它，然後將它傳入一些針對抽象型別寫的程式碼中，實現客戶和具體產品的解耦。

最後說一下抽象工廠模式的設計原則：依賴抽象，不依賴具體類。

需要再看，雖然程式碼寫完了，但依舊感覺糊里糊塗的，總結也沒有寫清楚。