C++设计模式之抽象工厂模式（Abstract Factory）

抽象工厂(Abstract  Factory)
1 .标准定义
抽象工厂模式标准定义：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
2.适用性：
一个系统要独立于它的产品的创建、组合和表示时。
一个系统要由多个产品系列中的一个来配置时。
当你要强调一系列相关的产品对象的设计以便进行联合使用时。
当你提供一个产品类库，而只想显示它们的接口而不是实现时。
3. 分析和说明
抽象工厂模式是一个创建性的模式。与工厂方法模式一样，它要求工厂类和产品类分开。但是核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。一个具体的工厂类负责创建产品族中的各个产品。其实质就是由1个工厂类层次、N个产品类层次和N×M个产品组成。
Abstract Factory结构如图1所示。抽象工厂模式包括四个角色：抽象工厂角色；具体工厂类角色；抽象产品角色和具体产品角色。分别描述如下。
a.抽象工厂（Abstract Factory）角色：担任这个角色的是工厂方法模式的核心，它是与应用系统的商业逻辑无关的。通常使用接口或者抽象类实现，而所有的具体工厂类必须实现这个接口或继承这个抽象类。
b.具体工厂类（Concrete Factory）角色：这个角色直接在客户端的调用下创建产品的实例。这个角色含有选择合适的产品对象的逻辑，而这个逻辑是与应用系统的商业逻辑紧密相关的。实际应用中使用具体类来实现这个角色。
c.抽象产品（Abstract Product）角色：担任这个角色的类是工厂方法模式所创建的对象的父类，或它们共同拥有的接口。通常使用接口或者抽象类来实现这一角色。
d.具体产品（Concrete Product）角色：抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。这是客户端最终需要的东西，其内部一定充满了应用系统的商业逻辑。实际应用中使用具体类来实现这个角色。
4.优缺点
优点：(1)封装创建过程。客户不用知道类厂是如何创建类实例的，类厂封闭了所有创建的细节。这样可选择不同的创建方法，增加了灵活性。 (2)将客户与具体类隔离，提高了各自的可重用性。
缺点：Factory类层次与具体类层次通常是平行的(即一一对应的)。增加一个具体类，一般也要相应地增加一个factory类，增加了系统复杂度。
5.抽象工厂与工厂方法以及简单工厂之间的对比：
1）首先介绍简单工厂模式，它的主要特点是需要在工厂类中做判断，从而创造相应的产品。当增加新的产品时，就需要修改工厂类。举个例子说明。有一家生产处理器核的厂家，它只有一个工厂，能够生产两种型号的处理器核。客户需要什么样的处理器核，一定要显示地告诉生产工厂。
2）工厂方法模式举例说明：这家生产处理器核的产家赚了不少钱，于是决定再开设一个工厂专门用来生产B型号的单核，而原来的工厂专门用来生产A型号的单核。这时，客户要做的是找好工厂，比如要A型号的核，就找A工厂要；否则找B工厂要，不再需要告诉工厂具体要什么型号的处理器核了。工厂方法模式也有缺点，每增加一种产品，就需要增加一个对象的工厂。如果这家公司发展迅速，推出了很多新的处理器核，那么就要开设相应的新工厂。在C++实现中，就是要定义一个个的工厂类。显然，相比简单工厂模式，工厂方法模式需要更多的类定义。
3） 抽象工厂模式举例说明：这家公司的技术不断进步，不仅可以生产单核处理器，也能生产多核处理器。现在简单工厂模式和工厂方法模式都鞭长莫及。抽象工厂模式登场了。它的定义为提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。具体这样应用，这家公司还是开设两个工厂，一个专门用来生产A型号的单核多核处理器，而另一个工厂专门用来生产B型号的单核多核处理器，

a.工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类只能创建一个具体产品类的实例。
b.抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类可以创建多个具体产品类的实例，也就是创建的是一个产品线下的多个产品。   
    
区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。   
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。
工厂方法创建 "一种" 产品，他的着重点在于"怎么创建"，也就是说如果你开发，你的大量代码很可能围绕着这种产品的构造，初始化这些细节上面。因此，类似的产品之间有很多可以复用的特征，所以会和模版方法相随。 所以说抽象工厂就像工厂，而工厂方法则像是工厂的一种产品生产线


6.C++代码实现：
#include<iostream>
using namespace std;


//抽象工厂类A 
class AbstractProductA{
private:
public: 
virtual ~AbstractProductA()
{
cout<<"~AbstractProductA！"<<endl; 
}
protected: 
AbstractProductA()
{
cout<<"AbstractProductA初始化！"<<endl;
}
};
// 抽象工厂类B
class AbstractProductB{
private:
public: 
virtual ~AbstractProductB()
{
cout<<"~AbstractProductB！"<<endl;
}
protected: 
AbstractProductB()
{
cout<<"AbstractProductB初始化！"<<endl;
}
};
//具体产品类A1 ，表示产品A的一种实现 
class ProductA1:public AbstractProductA{
protected: 
private:
public: 
ProductA1()
{
cout<<"ProductA1初始化！"<<endl;
}
~ProductA1()
{
cout<<"~ProductA1！"<<endl;
}
};
//具体产品类A2 ，表示产品A的另一种实现 
class ProductA2:public AbstractProductA{
protected: 
private:
public: 
ProductA2()
{
cout<<"ProductA2初始化！"<<endl;
}
~ProductA2()
{
cout<<"~ProductA2！"<<endl;
}
};
//具体产品类B1 ，表示产品B的一种实现 
class ProductB1:public AbstractProductB{
public: 
ProductB1()
{
cout<<"ProductB1初始化！"<<endl;
} 
~ProductB1()
{
cout<<"~ProductB1！"<<endl;
}
protected:
private:
};
//具体产品类B2 ，表示产品A的另一种实现 
class ProductB2:public AbstractProductB{
public: 
ProductB2()
{
cout<<"ProductB2初始化！"<<endl;
} 
~ProductB2()
{
cout<<"~ProductB2！"<<endl;
}
protected: 
private:
};


//抽象工厂类 
class AbstractFactory{
private:
public: 
virtual ~AbstractFactory()
{
cout<<"~AbstractFactory！"<<endl;
} 
//创建不同产品接口 
virtual AbstractProductA* CreateProductA() = 0; 
virtual AbstractProductB* CreateProductB() = 0;
protected: 
AbstractFactory()
{
cout<<"AbstractFactory初始化！"<<endl;
}
};
//具体工厂类1 
class ConcreteFactory1:public AbstractFactory{
protected:
private:
public: 
ConcreteFactory1()
{
cout<<"ConcreteFactory1初始化！"<<endl;
} 
~ConcreteFactory1()
{
cout<<"~ConcreteFactory1！"<<endl;
}
AbstractProductA* CreateProductA()
{
//实现产品A1 
return new ProductA1();
}
AbstractProductB* CreateProductB()
{
//实现产品B1 
return new ProductB1();
}
};
//具体工厂类2
class ConcreteFactory2:public AbstractFactory{
protected:
private:
public: 
ConcreteFactory2()
{
cout<<"ConcreteFactory2初始化！"<<endl;
}
~ConcreteFactory2()
{
cout<<"~ConcreteFactory2！"<<endl;
} 
AbstractProductA* CreateProductA()
{
//实现产品A2
return new ProductA2();
} 
AbstractProductB* CreateProductB()
{
//实现产品B2 
return new ProductB2();
}
};


int main(int argc,char* argv[])
{ 
//创建具体工厂1 
AbstractFactory* af1 = new ConcreteFactory1(); 
af1->CreateProductA(); 
af1->CreateProductB(); 
//创建具体工厂2
AbstractFactory* af2 = new ConcreteFactory2(); 
af2->CreateProductA(); 
af2->CreateProductB(); 
delete af1;
delete af2;
return 0;
}