创建型模式之抽象工厂模式(AbstractFactory Pattern)C++实现******

抽象工厂模式(AbstractFactory Pattern)创建型模式.

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

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

  Factory模式仅仅局限于一类类(所有的类有一个共同的基类)，如果要为不同类的类提供一个对象创建的接口，需要采用抽象工厂模式。

AbstractFactory模式关键就是将这一组对象的创建封装到一个用于创建对象的类（ConcreteFactory）中，维护这样一个创建类总比维护n多相关对象的创建过程要简单的多。

 

区别：抽象工厂和工厂方法都是负责创建对象，但是工厂方法用的是继承。抽象工厂采用的是对象的组合。

抽象工厂是用来创建一个产品家族的抽象类型，这个类型的子类定义了产品被产生的方法。它把一群相关的产品集合起来。所有的工厂模式都通过减少应用程序和具体类之间的依赖促进松耦合。抽象工厂创建相关的对象家族，而不需要依赖它们的具体类。

 

例子：HeadFirst中Pizza店根据地区的不同选择生成Pizza的原料，如面团，酱料等，所以它们是一个个类。它们的实例化需要放到一个工厂去管理创建。需要用的时候问工厂要就可以了。抽象原料工厂定义了如何产生一个相关产品的家族。这个家族包含了所有的原料。

抽象工厂的类图：

对应的Pizza店的类图：

实际上，AbstractFactory模式是为创建一组（有多类）相关或依赖的对象提供创建接口，而Factory模式正如我在相应的文档中分析的是为一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到，AbstractFactory模式通常都是使用Factory模式实现

HeadFirst中Pizza店 抽象工厂C++实现：

Product.h头文件：

#ifndef _PRODUCT_H_
#define _PRODUCT_H_
#include <string>
#include <list>
using namespace std;
#include "AbstractFactory.h"
//class PizzaIngredientFactory;
// AbstractProductA
class Dough
{
public:
virtual ~Dough();
protected:
Dough();
private:
};

//AbstractProductB
class Sauce
{
public:
virtual ~Sauce();
protected:
Sauce();
private:
};
//AbstractProductC

class Clams
{
public:
virtual ~Clams();
protected:
Clams();
private:
};

//具体产品类
class ThickCrustDough:public Dough
{
	public:
ThickCrustDough();
~ThickCrustDough();
protected:
private:
};

class ThinCrusDough:public Dough
{
public:
ThinCrusDough();
~ThinCrusDough();
protected:
private:
};

class PlumTomatoSauce:public Sauce
{
public:
PlumTomatoSauce();
~PlumTomatoSauce();
protected:
private:
};

class MarinaraSauce:public Sauce
{
	public:
MarinaraSauce();
~MarinaraSauce();
protected:
private:
};

class FrozenClams:public Clams
{
public:
FrozenClams();
~FrozenClams();
protected:
private:
};

class FreshClams:public Clams
{
public:
FreshClams();
~FreshClams();
protected:
private:
};









class Pizza
{
public:
	//相比工厂模式，其他方法不变，只需prepare()方法改变
	virtual ~Pizza();
	virtual void prepare()=0;//不同的Pizza原料不同，通过子类实现
	virtual void bake();
	virtual void cut();
	virtual void box();
	string getName();
	void setName(string name);

protected:
	 Pizza();
     string name;
     Dough *dough;
     Sauce *sauce;
     Clams *clams;

	//不同于工厂模式，这里换成对象
	//string name; //比萨名称
	//string dough;//面团类型
	//string sauce;//酱料的类型
   
};

class CheesePizza:public Pizza
{
	public:
	CheesePizza(PizzaIngredientFactory *ingredientFactory);
	~CheesePizza();
	void prepare();
protected:
	PizzaIngredientFactory *ingredientFactory;
  
};

class ClamPizza:public Pizza
{
public:
	ClamPizza(PizzaIngredientFactory *ingredientFactory);
	~ClamPizza();
	void prepare();
protected:
	PizzaIngredientFactory *ingredientFactory;
};

#endif

Product.CPP源文件

#include "Product.h"
#include <iostream>
using namespace std;

Dough::Dough()
{

}
Dough::~Dough()
{

}

Sauce::Sauce()
{

}
Sauce::~Sauce()
{

}

Clams::Clams()
{

}

Clams::~Clams()
{

}
ThickCrustDough::ThickCrustDough()
{
	cout<<"adding ThickCrustDough"<<endl;

}
ThickCrustDough::~ThickCrustDough()
{
 
}

ThinCrusDough::ThinCrusDough()
{
	cout<<"adding ThinCrusDough"<<endl;
}
ThinCrusDough::~ThinCrusDough()
{

}


PlumTomatoSauce::PlumTomatoSauce()
{
	cout<<"adding PlumTomatoSauce"<<endl;
}
PlumTomatoSauce::~PlumTomatoSauce()
{

}


MarinaraSauce::MarinaraSauce()
{
cout<<"adding MarinaraSauce"<<endl;
}
MarinaraSauce::~MarinaraSauce()
{

}




FrozenClams::FrozenClams()
{
cout<<"adding FrozenClams"<<endl;
}

FrozenClams::~FrozenClams()
{

}

FreshClams::FreshClams()
{
cout<<"adding FreshClams"<<endl;
}

FreshClams::~FreshClams()
{

}


//抽象Pizza类
Pizza::Pizza()
{

}
Pizza::~Pizza()
{

}

void Pizza::bake()
{
cout<<"Bake for 25 minutes at 350"<<endl;

}
void Pizza::cut()
{
cout<<"cutting the pizza into diagonal slices"<<endl;

}

void Pizza::box()
{
	cout<<"Place pizza in official PizzaStore box"<<endl;

}

string Pizza::getName()
{
	return name;
}
void Pizza::setName(string name)
{
	this->name=name;
}



CheesePizza::CheesePizza(PizzaIngredientFactory *ingredientFactory)
{
	this->ingredientFactory=ingredientFactory;
}
CheesePizza::~CheesePizza()
{

}
void CheesePizza::prepare()
{
 cout<<"Preparing "<<name<<endl;
 dough=ingredientFactory->CreateDough();
 sauce=ingredientFactory->CreateSauce();
 clams=ingredientFactory->CreateClams();

}



ClamPizza::ClamPizza(PizzaIngredientFactory *ingredientFactory)
{
	this->ingredientFactory=ingredientFactory;
}
ClamPizza::~ClamPizza()
{

}
void ClamPizza::prepare()
{
 cout<<"Preparing "<<name<<endl;
 dough=ingredientFactory->CreateDough();
 sauce=ingredientFactory->CreateSauce();
 clams=ingredientFactory->CreateClams();

}

AbstractFactory.h头文件

#ifndef _ABSTRACTFACTORY_H_
#define _ABSTRACTFACTORY_H_
#include <string>
#include <list>
using namespace std;
class Dough;
class Sauce;
class Clams;
class Pizza;

//抽象工厂，负责对象的创建
class PizzaIngredientFactory
{
public:
virtual ~PizzaIngredientFactory();
//以下三个方法，子类必须重写
virtual Dough * CreateDough() = 0;
virtual Sauce * CreateSauce() = 0;
virtual Clams * CreateClams() = 0;
protected:
PizzaIngredientFactory();

};

class NYPizzaIngredientFactory:public PizzaIngredientFactory
{
public:
NYPizzaIngredientFactory();
~NYPizzaIngredientFactory();

 Dough * CreateDough();
 Sauce * CreateSauce();
 Clams * CreateClams();

};
 
class ChicagoPizzaIngredientFactory:public PizzaIngredientFactory
{
public:
ChicagoPizzaIngredientFactory();
~ChicagoPizzaIngredientFactory();

 Dough * CreateDough();
 Sauce * CreateSauce();
 Clams * CreateClams();
};




class PizzaStore
{
public:
	 virtual ~PizzaStore()=0;
     virtual Pizza * CreatePizza(string type)=0; //工厂方法,子类必须实现该方法，由子类负责创建各种Pizza,
     Pizza * OrderPizza(string type);
protected:
	PizzaStore();
};


class NYPizzaStore:public PizzaStore
{
public:
	 NYPizzaStore();
    ~NYPizzaStore();
    Pizza * CreatePizza(string type);
};




#endif

AbstractFactory.CPP源文件：

#include"AbstractFactory.h"
#include"Product.h"

PizzaIngredientFactory::PizzaIngredientFactory()
{

}

PizzaIngredientFactory::~PizzaIngredientFactory()
{

}


NYPizzaIngredientFactory::NYPizzaIngredientFactory()
{
	
}

NYPizzaIngredientFactory::~NYPizzaIngredientFactory()
{

}

Dough * NYPizzaIngredientFactory::CreateDough()
{
  return new ThinCrusDough();
}

Sauce* NYPizzaIngredientFactory::CreateSauce()
{
	return new MarinaraSauce();
}

Clams * NYPizzaIngredientFactory::CreateClams()
{
	return new FreshClams();
}



ChicagoPizzaIngredientFactory::ChicagoPizzaIngredientFactory()
{

}
ChicagoPizzaIngredientFactory::~ChicagoPizzaIngredientFactory()
{

}

Dough * ChicagoPizzaIngredientFactory::CreateDough()
{
  return new ThickCrustDough();
}

Sauce* ChicagoPizzaIngredientFactory::CreateSauce()
{
	return new PlumTomatoSauce();
}

Clams * ChicagoPizzaIngredientFactory::CreateClams()
{
	return new FrozenClams();
}






PizzaStore::PizzaStore()
{

}
PizzaStore::~PizzaStore()
{
 
}
Pizza * PizzaStore::OrderPizza(string type)
{
  Pizza *pizza=CreatePizza(type);
  pizza->prepare();
  pizza->bake();
  pizza->cut();
  pizza->box();
  return pizza;
}


NYPizzaStore::NYPizzaStore()
{

}

NYPizzaStore::~NYPizzaStore()
{

}

Pizza * NYPizzaStore::CreatePizza(string type)
{
	Pizza * pizza=NULL;
	PizzaIngredientFactory  *ingredientFactory=new NYPizzaIngredientFactory();

	if("cheese"==type)
	{
	pizza=new CheesePizza(ingredientFactory);
	pizza->setName("New York Style Cheese Pizza");
	}
	else if ("clam"==type)
	{
		pizza=new ClamPizza(ingredientFactory);
		pizza->setName("New York Style Clam Pizza");

	}
	else
		pizza=NULL;
	return pizza;

}

主函数main.CPP

#include "Product.h"
#include "AbstractFactory.h"
#include <iostream>
using namespace std;
int main(int argc,char* argv[])
{ 
	//订购流程
	//1.选择一个比萨店
    PizzaStore *nyPizzaStore=new NYPizzaStore();
    //2.接受订单
    Pizza *pizza=nyPizzaStore->OrderPizza("cheese");
    cout<<"I ordered a "<<pizza->getName()<<endl;
	return 0;
}

复制 搜索

复制 搜索

复制 搜索

复制 搜索