工厂模式 C++实现

工厂方法用来处理对象的创建，并将这样的行为封装在子类中。这样，客户程序中关于超类的代码就和子类对象的对象创建代码解耦了。

 Abstract Product factoryMethod(string type)

 工厂方法是抽象的，所以依赖子类处理对象的创建 

 工厂方法必须返回一个产品。超类中定义的方法，通常使用工厂方法的返回值

 工厂方法将客户(也就是超类中的代码例如orederPizza())和实际创建具体产品的代码分隔开来。

工厂方法模式：定义了一个创建对象的接口，但由子类决定要实现例化的类是哪一个。工厂方法让类把实例化推迟到子类。

工厂方法和创建者是否总是抽象的？

  不是的，可以定义一个默认的工厂方法来产生某些具体的产品，这么一来，即使创建者没有任何子类，依然可以创建产品。

简单工厂不具备工厂方法的弹性，简单工厂把全部的事情，在一个地方都处理完了，然而工厂方法却是一个框架，让子类如何实现。简单工厂不能变更正在创建的产品。

工厂方法的优点：

  将创建对象的代码集中在一个对象或方法中，可以避免代码中的重复，并且方便以后的维护。这也意味着客户在实例化对象时，只依赖于接口，而不是具体类。

依赖倒置原则：要依赖抽象，不要依赖具体类。

抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

抽象工厂的任务是定义一个负责创建一组产品的接口。这个接口内的每个方法都负责创建一个具体产品，同时我们利用实现抽象工厂的子类来提供这些具体的做法。

工厂模式与抽象工厂：

  工厂方法：创建对象用的是继承，抽象工厂是通过对象的组合，把一群相关的产品集合起来。需要一个很大的接口。都可以将对象封装起来，使应用程序解耦，并降低其对特定实现的依赖。

--------------------------------------------C++源码pizza-----------------------------------------------------------------------------------------------------------------

#include <iostream>
#include <vector>
#include <string>
using namespace std;
class Pizza //产品类的接口
{
public:
	string name;
	string dough;//可以定义成原料工厂的参数
	string sauce;
	vector<string>toppings;
	void prepare()
	{
		cout<<"Preparing "<<name<<endl;
		cout<<"Tossing dough..."<<endl;
		cout<<"Adding sauce..."<<endl;
		cout<<"Adding topings:"<<endl;
		for (int i=0;i<toppings.size();i++)
		{
			cout<<" "<<toppings[i]<<endl;
		}
	}
	void bake()
	{
		cout<<"bake for 25 minutes at 350"<<endl;
	}
	virtual void cut()
	{
		cout<<"Cutting the pizza into diagonal slices"<<endl;
	}
	void box()
	{
		cout<<"Place pizza in officeal PizzaStore box"<<endl;
	}
	string getName()
	{
		return name;
	}
	virtual ~Pizza(){}
};
class NYStyleCheesePizza:public Pizza //产品类的子类
{
public:
	NYStyleCheesePizza()
	{
		name="NY Style Sauce and Cheese Pizza";
		dough="Thin Crust Dough";
		sauce="Marinara Sauce";
		toppings.push_back("Grated Reggiano Chessa");
	}
};
class ChicagoStyleCheesePizza:public Pizza
{
public:
	ChicagoStyleCheesePizza()
	{
		name="Chicago Style Deep Dish Cheese Pizza";
		dough="Extra Thick Crust Dough";
		sauce="Plum Tomato Sauce";
		toppings.push_back("Shredded Mozzarella Cheese");
	}
	void cut()
	{
		cout<<"Cutting the pizza into square slices"<<endl;
	}
};
class PizzaStore	//创建者类，包含工厂生产的方法，但是不实现，由子类实现 同时创建与生产解耦
{
public:
	virtual Pizza *createPizza(string type)=0;//定义的是接口，返回类型必须是*统一；
	Pizza* orderPizza(string type)
	{									//这是抽象创建者类，它定义了一个抽象工厂方法，让子类实现此方法制造产品
		Pizza *pizza;
		pizza=createPizza(type);         //创建者通常会包含依赖于抽象产品的代码，而这些抽象产品由子类制造，
		pizza->prepare();//规范了生产步骤//创建者不需要真的知道在制造哪种具体产品
		pizza->bake();
		pizza->cut();
		pizza->box();
		return pizza;
	}
	virtual ~PizzaStore(){}
};
class NYPizzaStore:public PizzaStore //工厂子类，创建具体对象
{
private:
	Pizza* createPizza(string item)//每个加盟店都有自己的pizzstore子类，所以可以利用实现createpizza创建自己风味的pizza
	{
		if (item=="cheese")      //在此可以实现各种工厂的调用，只是需要改变一些代码的调用
		{
			return new NYStyleCheesePizza();//主要是由于在这new 返回类型要注意 将创建对象的代码封装或者集中起来
		}
	}
};
class ChicagoPizzaStore:public PizzaStore
{
private:
	Pizza *createPizza(string item)
	{
		if (item=="cheese")
		{
			return new ChicagoStyleCheesePizza();
		}
	}
};
int main()
{
	PizzaStore* nystore=new NYPizzaStore();
	PizzaStore* chicagostore=new ChicagoPizzaStore();
	Pizza *pizza=nystore->orderPizza("cheese");
	cout<<"Ethan ordered a "<<pizza->getName()<<endl;
	pizza=chicagostore->orderPizza("cheese");
	cout<<"Joel ordered a "<<pizza->getName()<<endl;
	delete nystore;
	delete chicagostore;
	delete pizza;
	return 0;
}