设计模式C++实现（1）——工厂模式

软件领域中的设计模式为开发人员提供了一种使用专家设计经验的有效途径。设计模式中运用了面向对象编程语言的重要特性：封装、继承、多态，真正领悟设计模式的精髓是可能一个漫长的过程，需要大量实践经验的积累。最近看设计模式的书，对于每个模式，用C++写了个小例子，加深一下理解。主要参考《大话设计模式》和《设计模式:可复用面向对象软件的基础》两本书。本文介绍工厂模式的实现。

       工厂模式属于创建型模式，大致可以分为三类，简单工厂模式、工厂方法模式、抽象工厂模式。听上去差不多，都是工厂模式。下面一个个介绍，首先介绍简单工厂模式，它的主要特点是需要在工厂类中做判断，从而创造相应的产品。当增加新的产品时，就需要修改工厂类。有点抽象，举个例子就明白了。有一家生产处理器核的厂家，它只有一个工厂，能够生产两种型号的处理器核。客户需要什么样的处理器核，一定要显示地告诉生产工厂。下面给出一种实现方案。

[cpp]  view plain copy print ?

1. enum CTYPE {COREA, COREB};     
2. class SingleCore    
3. {    
4. public:    
5.     virtual void Show() = 0;  
6. };    
7. //单核A    
8. class SingleCoreA: public SingleCore    
9. {    
10. public:    
11.     void Show() { cout<<"SingleCore A"<<endl; }    
12. };    
13. //单核B    
14. class SingleCoreB: public SingleCore    
15. {    
16. public:    
17.     void Show() { cout<<"SingleCore B"<<endl; }    
18. };    
19. //唯一的工厂，可以生产两种型号的处理器核，在内部判断    
20. class Factory    
21. {    
22. public:     
23.     SingleCore* CreateSingleCore(enum CTYPE ctype)    
24.     {    
25.         if(ctype == COREA) //工厂内部判断    
26.             return new SingleCoreA(); //生产核A    
27.         else if(ctype == COREB)    
28.             return new SingleCoreB(); //生产核B    
29.         else    
30.             return NULL;    
31.     }    
32. };    

       这样设计的主要缺点之前也提到过，就是要增加新的核类型时，就需要修改工厂类。这就违反了开放封闭原则：软件实体（类、模块、函数）可以扩展，但是不可修改。于是，工厂方法模式出现了。所谓工厂方法模式，是指定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

       听起来很抽象，还是以刚才的例子解释。这家生产处理器核的产家赚了不少钱，于是决定再开设一个工厂专门用来生产B型号的单核，而原来的工厂专门用来生产A型号的单核。这时，客户要做的是找好工厂，比如要A型号的核，就找A工厂要；否则找B工厂要，不再需要告诉工厂具体要什么型号的处理器核了。下面给出一个实现方案。

[cpp]  view plain copy print ?

1. class SingleCore    
2. {    
3. public:    
4.     virtual void Show() = 0;  
5. };    
6. //单核A    
7. class SingleCoreA: public SingleCore    
8. {    
9. public:    
10.     void Show() { cout<<"SingleCore A"<<endl; }    
11. };    
12. //单核B    
13. class SingleCoreB: public SingleCore    
14. {    
15. public:    
16.     void Show() { cout<<"SingleCore B"<<endl; }    
17. };    
18. class Factory    
19. {    
20. public:    
21.     virtual SingleCore* CreateSingleCore() = 0;  
22. };    
23. //生产A核的工厂    
24. class FactoryA: public Factory    
25. {    
26. public:    
27.     SingleCoreA* CreateSingleCore() { return new SingleCoreA; }    
28. };    
29. //生产B核的工厂    
30. class FactoryB: public Factory    
31. {    
32. public:    
33.     SingleCoreB* CreateSingleCore() { return new SingleCoreB; }    
34. };    

       工厂方法模式也有缺点，每增加一种产品，就需要增加一个对象的工厂。如果这家公司发展迅速，推出了很多新的处理器核，那么就要开设相应的新工厂。在C++实现中，就是要定义一个个的工厂类。显然，相比简单工厂模式，工厂方法模式需要更多的类定义。

       既然有了简单工厂模式和工厂方法模式，为什么还要有抽象工厂模式呢？它到底有什么作用呢？还是举这个例子，这家公司的技术不断进步，不仅可以生产单核处理器，也能生产多核处理器。现在简单工厂模式和工厂方法模式都鞭长莫及。抽象工厂模式登场了。它的定义为提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。具体这样应用，这家公司还是开设两个工厂，一个专门用来生产A型号的单核多核处理器，而另一个工厂专门用来生产B型号的单核多核处理器，下面给出实现的代码。

[cpp]  view plain copy print ?

1. //单核    
2. class SingleCore     
3. {    
4. public:    
5.     virtual void Show() = 0;  
6. };    
7. class SingleCoreA: public SingleCore      
8. {    
9. public:    
10.     void Show() { cout<<"Single Core A"<<endl; }    
11. };    
12. class SingleCoreB :public SingleCore    
13. {    
14. public:    
15.     void Show() { cout<<"Single Core B"<<endl; }    
16. };    
17. //多核    
18. class MultiCore      
19. {    
20. public:    
21.     virtual void Show() = 0;  
22. };    
23. class MultiCoreA : public MultiCore      
24. {    
25. public:    
26.     void Show() { cout<<"Multi Core A"<<endl; }    
27.     
28. };    
29. class MultiCoreB : public MultiCore      
30. {    
31. public:    
32.     void Show() { cout<<"Multi Core B"<<endl; }    
33. };    
34. //工厂    
35. class CoreFactory      
36. {    
37. public:    
38.     virtual SingleCore* CreateSingleCore() = 0;  
39.     virtual MultiCore* CreateMultiCore() = 0;  
40. };    
41. //工厂A，专门用来生产A型号的处理器    
42. class FactoryA :public CoreFactory    
43. {    
44. public:    
45.     SingleCore* CreateSingleCore() { return new SingleCoreA(); }    
46.     MultiCore* CreateMultiCore() { return new MultiCoreA(); }    
47. };    
48. //工厂B，专门用来生产B型号的处理器    
49. class FactoryB : public CoreFactory    
50. {    
51. public:    
52.     SingleCore* CreateSingleCore() { return new SingleCoreB(); }    
53.     MultiCore* CreateMultiCore() { return new MultiCoreB(); }    
54. };   

        至此，工厂模式介绍完了。利用Rational Rose 2003软件，给出三种工厂模式的UML图，加深印象。

         简单工厂模式的UML图：

         工厂方法的UML图：

         抽象工厂模式的UML图：

         本人享有博客文章的版权，转载请标明出处 http://blog.csdn.net/wuzhekai1985

抽象工厂模式的优点

• 封装性，每个产品的实现类不是高层模块要关系的，要关心的是什么？是接口，是抽象，它不关心对象是如何创建出来，这由谁负责呢？工厂类，只要知道工厂类是谁，我就能创建出一个需要的对象，省时省力，优秀设计就应该如此。
• 产品族内的约束为非公开状态。例如生产男女比例的问题上，猜想女娲娘娘肯定有自己的打算，不能让女盛男衰，否则女性的优点不就体现不出来了吗？那在抽象工厂模式，就应该有这样的一个约束：每生产1个女性，就同时生产出1.2个男性，这样的生产过程对调用工厂类的高层模块来说是透明的，它不需要知道这个约束，我就是要一个黄色女性产品就可以了，具体的产品族内的约束是在工厂内实现的。

抽象工厂模式的缺点

抽象工厂模式的最大缺点就是产品族扩展非常困难，为什么这么说呢？我们以通用代码为例，如果要增加一个产品C，也就是说有产品家族由原来的2个，增加到3个，看看我们的程序有多大改动吧！抽象类AbstractCreator要增加一个方法createProductC()，然后，两个实现类都要修改，想想看，这在项目中的话，还这么让人活！严重违反了开闭原则，而且我们一直说明抽象类和接口是一个契约，改变契约，所有与契约有关系的代码都要修改，这段代码叫什么？叫“有毒代码”，——只要这段代码有关系，就可能产生侵害的危险！

抽象工厂模式的使用场景

 抽象工厂模式的使用场景定义非常简单：一个对象族（或是一组没有任何关系的对象）都有相同的约束，则可以使用抽象工厂模式，什么意思呢？例如一个文本编辑器和一个图片处理器，都是软件实体，但是*nix下的文本编辑器和WINDOWS下的文本编辑器虽然功能和界面都相同，但是代码实现是不同的，图片处理器也是类似情况，也就是具有了共同的约束条件：操作系统类型，于是我们可以使用抽象工厂模式，产生不同操作系统下的编辑器和图片处理器。

最佳实践

一个模式在什么情况下才能够使用，是很多读者比较困惑的地方，抽象工厂模式是一个简单的模式，使用的场景非常多，大家在软件产品开发过程中，涉及到不同操作系统的时候，都可以考虑使用抽象工厂模式，例如一个应用，需要在三个不同平台上运行：Windows、Linux、Android（Google发布的智能终端操作系统）上运行，你会怎么设计？分别设计三套不同的应用？非也非也，通过抽象工厂模式屏蔽掉操作系统对应用的影响。三个不同操作系统上的软件功能、应用逻辑、UI都应该是非常类似，唯一不同的是调用不同的工厂方法，由不同的产品类去处理与操作系统交互的信息。