C++：抽象工厂模式

抽象工厂模式

抽象工厂模式就变得比工厂模式更为复杂，就像上面提到的缺点一样，工厂模式和简单工厂模式要求产品子类必须要是同一类型的，拥有共同的方法，这就限制了产品子类的扩展。于是为了更加方便的扩展，抽象工厂模式就将同一类的产品子类归为一类，让他们继承同一个抽象子类，我们可以把他们一起视作一组，然后好几组产品构成一族。

此时，客户端要使用时必须知道是哪一个工厂并且是哪一组的产品抽象类。每一个工厂子类负责产生一族产品，而子类的一种方法产生一种类型的产品。在客户端看来只有AbstractProductA和AbstractProductB两种产品，使用的时候也是直接使用这两种产品。而通过工厂来识别是属于哪一族产品。

产品ProductA_1和ProductB_1构成一族产品，对应于有Factory1来创建，也就是说Factory1总是创建的ProductA_1和ProductB_1的产品，在客户端看来只需要知道是哪一类工厂和产品组就可以了。一般来说， ProductA_1和ProductB_1都是适应同一种环境的，所以他们会被归为一族。

常用的场景

例如Linux和windows两种操作系统下，有2个挂件A和B，他们在Linux和Windows下面的实现方式不同，Factory1负责产生能在Linux下运行的挂件A和B，Factory2负责产生能在Windows下运行的挂件A和B，这样如果系统环境发生变化了，我们只需要修改工厂就行了。

优点

1.封装了产品的创建，使得不需要知道具体是哪种产品，只需要知道是哪个工厂就行了。

2.可以支持不同类型的产品，使得模式灵活性更强。

3.可以非常方便的使用一族中间的不同类型的产品。

缺点

1.结构太过臃肿，如果产品类型比较多，或者产品族类比较多，就会非常难于管理。

2.每次如果添加一组产品，那么所有的工厂类都必须添加一个方法，这样违背了开放-封闭原则。所以一般适用于产品组合产品族变化不大的情况。

C++实现代码

 1 #ifndef _ABSTRACTPRODUCTA_H_
 2 #define _ABSTRACTPRODUCTA_H_
 3 
 4 
 5 #include <stdio.h>
 6 
 7 
 8 class AbstractProductA{
 9 
10 public:
11     AbstractProductA();
12     virtual ~AbstractProductA();
13     
14 public:
15     virtual void operationA() = 0;
16 };
17 
18 class ProductA_1:public AbstractProductA{
19 
20 public:
21     ProductA_1();
22     virtual ~ProductA_1();
23     
24 public:
25     void operationA();
26 };
27 
28 class ProductA_2:public AbstractProductA{
29 
30 public:
31     ProductA_2();
32     ~ProductA_2();
33     
34 public:
35     void operationA();
36 };
37 
38 #endif

 1 #include "AbstractProductA.h"
 2 
 3 
 4 
 5 AbstractProductA::AbstractProductA(){
 6 }
 7 
 8 
 9 AbstractProductA::~AbstractProductA(){
10 }
11 
12 
13 ProductA_1::ProductA_1(){
14 }
15 
16 
17 ProductA_1::~ProductA_1(){
18 }
19 
20 
21 void ProductA_1::operationA(){
22     fprintf(stderr,"productA_1 operation!\n");
23 }
24 
25 
26 ProductA_2::ProductA_2(){
27 }
28 
29 
30 ProductA_2::~ProductA_2(){
31 }
32 
33 
34 void ProductA_2::operationA(){
35     fprintf(stderr,"productA_2 operation!\n");
36 }

 1 #ifndef _ABSTRACTPRODUCTB_H_
 2 #define _ABSTRACTPRODUCTB_H_
 3 
 4 
 5 #include <stdio.h>
 6 
 7 
 8 class AbstractProductB{
 9 
10 public:
11     AbstractProductB();
12     virtual ~AbstractProductB();
13     
14 public:
15     virtual void operationB() = 0;
16 };
17 
18 class ProductB_1:public AbstractProductB{
19 
20 public:
21     ProductB_1();
22     virtual ~ProductB_1();
23     
24 public:
25     void operationB();
26 };
27 
28 class ProductB_2:public AbstractProductB{
29 
30 public:
31     ProductB_2();
32     ~ProductB_2();
33     
34 public:
35     void operationB();
36 };
37 
38 #endif

 1 #include "AbstractProductB.h"
 2 
 3 
 4 
 5 AbstractProductB::AbstractProductB(){
 6 }
 7 
 8 
 9 AbstractProductB::~AbstractProductB(){
10 }
11 
12 
13 ProductB_1::ProductB_1(){
14 }
15 
16 
17 ProductB_1::~ProductB_1(){
18 }
19 
20 
21 void ProductB_1::operationB(){
22     fprintf(stderr,"productB_1 operation!\n");
23 }
24 
25 
26 ProductB_2::ProductB_2(){
27 }
28 
29 
30 ProductB_2::~ProductB_2(){
31 }
32 
33 
34 void ProductB_2::operationB(){
35     fprintf(stderr,"productB_2 operation!\n");
36 }

 1 #ifndef _SIMPLEFACTORY_H_
 2 #define _SIMPLEFACTROY_H_
 3 
 4 #include <stdio.h>
 5 #include "AbstractProductA.h"
 6 #include "AbstractProductB.h"
 7 
 8 
 9 class AbstractFactory{
10 
11 public:
12     AbstractFactory();
13     virtual ~AbstractFactory();
14     
15 public:
16     virtual AbstractProductA* createProductA() = 0;    
17     virtual AbstractProductB* createProductB() = 0;    
18 };
19 
20 
21 class Factory1:public AbstractFactory{
22 
23 public:
24     Factory1();
25     ~Factory1();
26     
27 public:
28     AbstractProductA* createProductA();
29     AbstractProductB* createProductB();
30 };
31 
32 
33 class Factory2:public AbstractFactory{
34 
35 public:
36     Factory2();
37     ~Factory2();
38     
39 public:
40     AbstractProductA* createProductA();
41     AbstractProductB* createProductB();
42 };
43 #endif

 1 #include "AbstractFactory.h"
 2 
 3 
 4 AbstractFactory::AbstractFactory(){
 5 }
 6 
 7 
 8 AbstractFactory::~AbstractFactory(){
 9 }
10 
11 
12 Factory1::Factory1(){
13 }
14 
15 
16 Factory1::~Factory1(){
17 }
18 
19 
20 AbstractProductA* Factory1::createProductA(){
21     AbstractProductA* temp = NULL;
22     temp = new ProductA_1();
23     return temp;
24 }
25 
26 
27 AbstractProductB* Factory1::createProductB(){
28     AbstractProductB* temp = NULL;
29     temp = new ProductB_1();
30     return temp;
31 }
32 
33 
34 Factory2::Factory2(){
35 }
36 
37 
38 Factory2::~Factory2(){
39 }
40 
41 
42 AbstractProductA* Factory2::createProductA(){
43     AbstractProductA* temp = NULL;
44     temp = new ProductA_2();
45     return temp;
46 }
47 
48 
49 AbstractProductB* Factory2::createProductB(){
50     AbstractProductB* temp = NULL;
51     temp = new ProductB_2();
52     return temp;
53 }

 1 #include "AbstractFactory.h"
 2 
 3 
 4 int main(){
 5 
 6     AbstractFactory* factory = new Factory1();
 7     AbstractProductA* productA = factory->createProductA();
 8     AbstractProductB* productB = factory->createProductB();
 9     productA->operationA();
10     productB->operationB();
11     
12     delete factory;
13     factory = NULL;
14     delete productA;
15     productA = NULL;
16     delete productB;
17     productB = NULL;
18     
19     factory = new Factory2();
20     productA = factory->createProductA();
21     productB = factory->createProductB();
22     productA->operationA();
23     productB->operationB();
24     
25     delete factory;
26     factory = NULL;
27     delete productA;
28     productA = NULL;
29     delete productB;
30     productB = NULL;
31     return 0;
32 }

1 g++ -o client AbstractProductA.cpp AbstractProductB.cpp AbstractFactory.cpp client.cpp

结果