C++设计模式-AbstractFactory抽象工厂模式

AbstractFactory

要创建一组相关或者相互依赖的对象

作用：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

UML结构图：

抽象基类：

1）AbstractProductA、AbstractProductB：分别代表两种不同类型的产品，由具体的产品派生类对其实现

2）AbstractFactory：抽象工厂类，提供创建两种产品的接口CreateProductA和CreateProductB，由派生的各个具体工厂类对其实现

说明：

AbstractFactory模式关键就是将这一组对象的创建封装到一个用于创建对象的类（ConcreteFactory）中

Abstract Factory模式和Factory最大的差别就是抽象工厂创建的是一系列相关的对象,其中创建的实现其实采用的就是Factory模式的方法,对于某个实现的有一个派生出来的抽象工厂,另一个实现有另一个派生出来的工厂

抽象工厂需要特别注意的地方就是区分不同类型的产品和这些产品的不同实现.显而易见的,如果有n种产品同时有m中不同的实现,那么根据乘法原理可知有n*m个Factory模式的使用

AbstractFactory模式是为创建一组（有多类）相关或依赖的对象提供创建接口，而Factory模式是为一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到，AbstractFactory模式通常都是使用Factory模式实现（ConcreteFactory1）。

代码如下：

Product.h

 #ifndef _PRODUCT_H_
 #define _PRODUCT_H_

 //抽象基类AbstractProductA，代表A类产品的抽象
 class AbstractProductA
 {
 public:
     virtual ~AbstractProductA()=;
     virtual void operation()=;
 protected:
     AbstractProductA();//屏蔽构造函数
 };

 //派生类ProductA1，继承自AbstractProductA，A类产品的一种实现
 class ProductA1 : public AbstractProductA
 {
 public:
     ProductA1();
     virtual void operation();
     virtual ~ProductA1();
 };

 //派生类ProductA2，继承自AbstractProductA，A类产品的另一种实现
 class ProductA2:public AbstractProductA
 {
 public:
     ProductA2();
     virtual void operation();
     virtual ~ProductA2();
 };

 //抽象基类AbstractProductB，代表B类产品的抽象
 class AbstractProductB
 {
 public:
     virtual ~AbstractProductB()=;
     virtual void operation()=;
 protected:
     AbstractProductB();//屏蔽构造函数
 };

 //派生类ProductB1，继承自AbstractProductB，B类产品的一种实现
 class ProductB1:public AbstractProductB
 {
 public:
     ProductB1();
     virtual void operation();
     virtual ~ProductB1();
 };

 //派生类ProductB2，继承自AbstractProductB，B类产品的另一种实现
 class ProductB2:public AbstractProductB
 {
 public:
     ProductB2();
     virtual void operation();
     virtual ~ProductB2();
 };

 #endif

Factory.h

 #ifndef _FACTORY_H_
 #define _FACTORY_H_

 //AbstractFactory，工厂抽象基类，定义生产A类与B类产品的接口
 class AbstractProductA;
 class AbstractProductB;
 class AbstractFactory
 {
 public:
     virtual ~AbstractFactory()=;
     virtual AbstractProductA* CreateProductA()=;
     virtual AbstractProductB* CreateProductB()=;
 protected:
     AbstractFactory();
 };

 //ConcreteFactory1，派生类，继承自AbstractFactory
 //实现继承的接口，生产产品A和B的一种实现
 class ConcreteFactory1:public AbstractFactory
 {
 public:
     ConcreteFactory1();
     ~ConcreteFactory1();
     virtual AbstractProductA* CreateProductA();
     virtual AbstractProductB* CreateProductB();
 };

 //ConcreteFactory2，派生类，继承自AbstractFactory
 //实现继承的接口，生产产品A和B的另一种实现
 class ConcreteFactory2:public AbstractFactory
 {
 public:
     ConcreteFactory2();
     ~ConcreteFactory2();
     virtual AbstractProductA* CreateProductA();
     virtual AbstractProductB* CreateProductB();
 };

 #endif

Product.cpp

 #include "Product.h"
 #include <iostream>

 using namespace std;

 //AbstractProductA
 AbstractProductA::AbstractProductA()
 {
     cout << "AbstractProductA..." << endl;
 }

 AbstractProductA::~AbstractProductA()
 {
     cout << "~AbstractProductA..." << endl;
 }

 //ProductA1
 ProductA1::ProductA1()
 {
     cout << "ProductA1..." << endl;
 }

 ProductA1::~ProductA1()
 {
     cout << "~ProductA1..." << endl;
 }

 void ProductA1::operation()
 {}

 //ProductA2
 ProductA2::ProductA2()
 {
     cout << "ProductA2..." << endl;
 }

 ProductA2::~ProductA2()
 {
     cout << "~ProductA2..." << endl;
 }

 void ProductA2::operation()
 {}

 //AbstractProductB
 AbstractProductB::AbstractProductB()
 {
     cout << "AbstractProductB..." << endl;
 }

 AbstractProductB::~AbstractProductB()
 {
     cout << "~AbstractProductB..." << endl;
 }

 //ProductB1
 ProductB1::ProductB1()
 {
     cout << "ProductB1..." << endl;
 }

 ProductB1::~ProductB1()
 {
     cout << "~ProductB1..." << endl;
 }

 void ProductB1::operation()
 {}

 //ProductB2
 ProductB2::ProductB2()
 {
     cout << "ProductB2..." << endl;
 }

 ProductB2::~ProductB2()
 {
     cout << "~ProductB2..." << endl;
 }

 void ProductB2::operation()
 {}

Factory.cpp

 #include "Factory.h"
 #include "Product.h"
 #include <iostream>

 using namespace std;

 AbstractFactory::AbstractFactory()
 {
     cout << "AbstractFactory..." << endl;
 }

 AbstractFactory::~AbstractFactory()
 {
     cout << "~AbstractFactory..." << endl;
 }

 ConcreteFactory1::ConcreteFactory1()
 {
     cout << "ConcreteFactory1..." << endl;
 }

 ConcreteFactory1::~ConcreteFactory1()
 {
     cout << "~ConcreteFactory1..." << endl;
 }

 AbstractProductA* ConcreteFactory1::CreateProductA()
 {
     return new ProductA1();
 }

 AbstractProductB* ConcreteFactory1::CreateProductB()
 {
     return new ProductB1();
 }

 ConcreteFactory2::ConcreteFactory2()
 {
     cout << "ConcreteFactory2..." << endl;
 }

 ConcreteFactory2::~ConcreteFactory2()
 {
     cout << "~ConcreteFactory2..." << endl;
 }

 AbstractProductA* ConcreteFactory2::CreateProductA()
 {
     return new ProductA2();
 }

 AbstractProductB* ConcreteFactory2::CreateProductB()
 {
     return new ProductB2();
 }

main.cpp

 #include <iostream>
 #include "Factory.h"
 #include "Product.h"

 using namespace std;

 int main()
 {
     AbstractFactory* fa1 = new ConcreteFactory1();
     AbstractProductA* a1 = fa1->CreateProductA();
     AbstractProductB* b1 = fa1->CreateProductB();

     cout << endl;
     AbstractFactory* fa2 = new ConcreteFactory2();
     AbstractProductA* a2 = fa2->CreateProductA();
     AbstractProductB* b2 = fa2->CreateProductB();

     cout << endl;
     delete fa1;
     delete a1;
     delete b1;

     cout << endl;
     delete fa2;
     delete a2;
     delete b2;

     return ;
 }