c++设计模式之抽象工厂模式

                                                                                                                          抽象工厂模式

 抽象工厂模式，就好比是多个工厂方法模式的叠加。抽象工厂创建的是一系列相关的对象，其中创建的实现其实就是采用的工厂方法模式。在工厂Factory中的每一个方法，就好比是一条生产线，而生产线实际需要生产什么样的产品，这是由Factory1和Factory2........去决定的，这样便延迟了具体子类的实例化；同时集中化了生产线的管理，节省了资源的浪费。

           

  

#include <iostream>
usingnamespacestd;
  
// Product A
classProductA
{
public:
  virtualvoidShow() = 0;
};
  
classProductA1 : publicProductA
{
public:
  voidShow()
  {
    cout<<"I'm ProductA1"<<endl;
  }
};
  
classProductA2 : publicProductA
{
public:
  voidShow()
  {
    cout<<"I'm ProductA2"<<endl;
  }
};
  
// Product B
classProductB
{
public:
  virtualvoidShow() = 0;
};
  
classProductB1 : publicProductB
{
public:
  voidShow()
  {
    cout<<"I'm ProductB1"<<endl;
  }
};
  
classProductB2 : publicProductB
{
public:
  voidShow()
  {
    cout<<"I'm ProductB2"<<endl;
  }
};
  
// Factory
classFactory
{
public:
  virtualProductA *CreateProductA() = 0;
  virtualProductB *CreateProductB() = 0;
};
  
classFactory1 : publicFactory
{
public:
  ProductA *CreateProductA()
  {
    returnnewProductA1();
  }
  
  ProductB *CreateProductB()
  {
    returnnewProductB1();
  }
};
  
classFactory2 : publicFactory
{
  ProductA *CreateProductA()
  {
    returnnewProductA2();
  }
  
  ProductB *CreateProductB()
  {
    returnnewProductB2();
  }
};
  
intmain(intargc,char*argv[])
{
  Factory *factoryObj1 = newFactory1();
  ProductA *productObjA1 = factoryObj1->CreateProductA();
  ProductB *productObjB1 = factoryObj1->CreateProductB();
  
  productObjA1->Show();
  productObjB1->Show();
  
  Factory *factoryObj2 = newFactory2();
  ProductA *productObjA2 = factoryObj2->CreateProductA();
  ProductB *productObjB2 = factoryObj2->CreateProductB();
  
  productObjA2->Show();
  productObjB2->Show();
  
  if(factoryObj1 != NULL)
  {
    deletefactoryObj1;
    factoryObj1 = NULL;
  }
  
  if(productObjA1 != NULL)
  {
    deleteproductObjA1;
    productObjA1= NULL;
  }
  
  if(productObjB1 != NULL)
  {
    deleteproductObjB1;
    productObjB1 = NULL;
  }
  
  if(factoryObj2 != NULL)
  {
    deletefactoryObj2;
    factoryObj2 = NULL;
  }
  
  if(productObjA2 != NULL)
  {
    deleteproductObjA2;
    productObjA2 = NULL;
  }
  
  if(productObjB2 != NULL)
  {
    deleteproductObjB2;
    productObjB2 = NULL;
  }
}

 

 

适用性：

• 一个系统要独立于它的产品的创建、组合和表示时
• 一个系统要由多个 产品系列中的一个来配置时
• 当你要强调一个系列相关的产品对象的设计以便进行联合使用时
• 当你提供一个产品类库，而只想显示它们的接口而不是实现时。

例：

当Factory基类表示厨师时时，用Factory1表示粤菜厨师，用Factory2表示川菜厨师，用product表示产品，用protectedA表示红烧肉，用productB表示清蒸鱼，但红烧肉又可分为粤式红烧肉（productA1）和川式红烧肉（productA2），同样的清蒸鱼可分为粤式清蒸鱼（productB1）和川式清蒸鱼（productB2）两种，并且粤式的鱼和红烧肉必须由粤式厨师才可做出，川式的鱼和红烧肉必须得由川式厨师做出这种场景就非常适合用抽象

工厂模式，

                                        

#include <iostream>
using namespace std;


/*
 * 食物基类 
 */ 
class productfood {
public:
	virtual void show() = 0;


	virtual ~productfood()
	{
	}
};


/*
 * 清蒸鱼基类 
 */
 
class  productfish : public productfood {
public:
	virtual void show() = 0;


	~productfish()
	{
	}
};


/*
 * 红烧肉基类 
 */
class  productmeat : public productfood {
public:
	virtual void show() = 0;


	~productmeat()
	{
	}
};


/*
 * 粤式清蒸鱼类 
 */
class productfish1 : public productfish {
public:
	void show()
	{
		cout << "这是粤式清蒸鱼！！" << endl;
	}


	~productfish1()
	{
	}
};


/*
 * 川式清蒸鱼类 
 */
class productfish2 : public productfish {
public:
	void show()
	{
		cout << "这是川式清蒸鱼！！" << endl;
	}


	~productfish2()
	{
	}
};


/*
 * 粤式红烧肉类 
 */
class productmeat1 : public productmeat {
public:
	void show()
	{
		cout << "这是粤式红烧肉！！" << endl;
	}


	~productmeat1()
	{
	}
};


/*
 * 川式红烧肉类 
 */
class productmeat2 : public productmeat {
public:
	void show()
	{
		cout << "这是川式红烧肉！！" << endl;
	}


	~productmeat2()
	{
	}
};


/*
 * 工厂基类（厨师基类） 
 *
 *
 */ 
class Factory {
private:
	productfood *pf;
public:
	Factory( productfood *pf )
	{
		this->pf = pf;
	}


	virtual void show() = 0;


	void inter()
	{
		pf->show();
	}


	~Factory()
	{
	}
};


/*
 * 粤菜厨师类 
 */ 
class Factory1 : public Factory {
public:
	Factory1( productfood *productfood ) : Factory( productfood )
	{
	}


	void show()
	{
		inter();
	}


	~Factory1()
	{
	}
};


/*
 * 川菜厨师类 
 */ 
class Factory2 : public Factory {
public:
	Factory2( productfood *productfood ) : Factory( productfood )
	{
	}


	void show()
	{
		inter();
	}


	~Factory2()
	{
	}
};
int main( void )
{
	productfood	*p1	= new productfish1();
	productfood	*p2	= new productfish2();
	productfood	*p3	= new productmeat1();
	productfood	*p4	= new productmeat2();
	Factory		*pf1	= new Factory1( p1 );
	Factory		*pf2	= new Factory1( p3 );
	Factory		*pf3	= new Factory2( p2 );
	Factory		*pf4	= new Factory2( p4 );
	pf1->show();
	pf2->show();
	pf3->show();
	pf4->show();
	delete pf1;
	delete pf2;
	delete pf3;
	delete pf4;
	delete p1;
	delete p2;
	delete p3;
	delete p4;
	return(0);
}