C++：工厂模式

工厂模式

工厂模式基本与简单工厂模式差不多，上面也说了，每次添加一个产品子类都必须在工厂类中添加一个判断分支，这样违背了开放-封闭原则，因此，工厂模式就是为了解决这个问题而产生的。

既然每次都要判断，那我就把这些判断都生成一个工厂子类，这样，每次添加产品子类的时候，只需再添加一个工厂子类就可以了。这样就完美的遵循了开放-封闭原则。但这其实也有问题，如果产品数量足够多，要维护的量就会增加，好在一般工厂子类只用来生成产品类，只要产品子类的名称不发生变化，那么基本工厂子类就不需要修改，每次只需要修改产品子类就可以了。

同样工厂模式一般应该于程序中大部分地方都只使用其中一种产品，工厂类也不用频繁创建产品类的情况。这样修改的时候只需要修改有限的几个地方即可。

 

常用的场景

基本与简单工厂模式一致，只不过是改进了简单工厂模式中的开放-封闭原则的缺陷，使得模式更具有弹性。将实例化的过程推迟到子类中，由子类来决定实例化哪个。

优点

基本与简单工厂模式一致，多的一点优点就是遵循了开放-封闭原则，使得模式的灵活性更强。

缺点

与简单工厂模式差不多。

C++实现代码

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

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

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

 1 #include "AbstractFactory.h"
 2 
 3 
 4 AbstractFactory::AbstractFactory(){
 5 }
 6 
 7 
 8 AbstractFactory::~AbstractFactory(){
 9 }
10 
11 
12 FactoryA::FactoryA(){
13 }
14 
15 
16 FactoryA::~FactoryA(){
17 }
18 
19 
20 AbstractProduct* FactoryA::createProduct(){
21     AbstractProduct* temp = NULL;
22     temp = new ProductA();
23     return temp;
24 }
25 
26 
27 FactoryB::FactoryB(){
28 }
29 
30 
31 FactoryB::~FactoryB(){
32 }
33 
34 
35 AbstractProduct* FactoryB::createProduct(){
36     AbstractProduct* temp = NULL;
37     temp = new ProductB();
38     return temp;
39 }

 1 #include "AbstractFactory.h"
 2 
 3 
 4 int main(){
 5     AbstractFactory* factory = new FactoryA();
 6     AbstractProduct* product = factory->createProduct();
 7     product->operation();
 8     delete product;
 9     product = NULL;
10     delete factory;
11     factory = NULL;
12     
13     factory = new FactoryB();
14     product = factory->createProduct();
15     product->operation();
16     delete product;
17     product = NULL;
18     delete factory;
19     factory = NULL;
20     return 0;
21 }

1 g++ -o client client.cpp AbstractFactory.cpp AbstractProduct.cpp

结果