简单的工厂模式

一.简单工厂模式又称静态工厂方法模式（Static Factory Method），它不是Gof 所讲的23种设计模式之一，但是它却是我们在编码过程中经常使用的方法之一。

 

1.静态工厂方法统一管理对象的创建。
静态工厂方法通过传入的参数判断决定创建哪一个产品的实例，封装了对象的创建，客户端只管消费，实现了对责任（模块）的分割。

2.静态工厂方法推迟了产品的实例化。
通过XML配置文件就能改变具体要创建的产品实例，修改为其它的产品实例，代码不须重新编译。

 

二.简单工厂模式还是有缺点的，后面的工厂方法模式和抽象工厂模式就是对这些缺点的改善。讲完了这三种模式将会有一个对比。以下以Nokia手机为例，采用简单工厂模式设计的源代码雏形。

[cpp] view plain copy print ?

1. /* Nokia抽象产品 */  
2. #pragma once   
3. #include <string>   
4. #include <iostream>   
5. class CNokia  
6. {  
7. public:  
8.     CNokia(void);  
9. public:  
10.     virtual ~CNokia(void);  
11. public:  
12.     virtual bool MakeCall(const std::string & number) const = 0;  
13. };  
14. #include "Nokia.h"   
15.   
16. CNokia::CNokia(void)  
17. {  
18. }  
19.   
20. CNokia::~CNokia(void)  
21. {  
22. }  
23.   
24. #pragma once   
25. #include "nokia.h"   
26.   
27. class CN96 : public CNokia  
28. {  
29. public:  
30.     CN96(void);  
31. public:  
32.     virtual ~CN96(void);  
33. public:  
34.     virtual bool MakeCall(const std::string & number) const;  
35. };  
36.   
37. /* N96型号的Nokia手机产品类 */  
38. #include "N96.h"   
39.   
40. CN96::CN96(void)  
41. {  
42.     std::cout << "生产一部N96" << std::endl;  
43. }  
44.   
45. CN96::~CN96(void)  
46. {  
47. }  
48.   
49. bool CN96::MakeCall(const std::string & number) const  
50. {  
51.     std::cout << "我在用N96，拨打号码是：" <<  number.c_str() << std::endl;  
52.     return false;  
53. }  
54.   
55. #pragma once   
56. #include "nokia.h"   
57.   
58. class CN95 :public CNokia  
59. {  
60. public:  
61.     CN95(void);  
62. public:  
63.     virtual ~CN95(void);  
64. public:  
65.     virtual bool MakeCall(const std::string & number) const;  
66. };  
67.   
68. /* N95型号的Nokia手机产品类 */  
69. #include "N95.h"   
70.   
71. CN95::CN95(void)  
72. {  
73.     std::cout << "生产一部N95" << std::endl;  
74. }  
75.   
76. CN95::~CN95(void)  
77. {  
78. }  
79.   
80. bool CN95::MakeCall(const std::string & number) const  
81. {  
82.     std::cout << "我在用N95，拨打号码是：" <<  number.c_str() << std::endl;  
83.     return false;  
84. }  
85.   
86. /*N85, N81, ...*/  
87.   
88. /* 工厂类 */  
89. #pragma once   
90. #include "N96.h"   
91. #include "N95.h"   
92. #include "N85.h"   
93. #include "N81.h"   
94. #include <cassert>   
95. class CNokiaSimpleFactory  
96. {  
97. public:  
98.     CNokiaSimpleFactory(void);  
99. public:  
100.     ~CNokiaSimpleFactory(void);  
101. public:  
102.          /* 静态工厂方法 */  
103.     static CNokia * CreateNokia(const std::string & model);  
104. };  
105.   
106. #include "NokiaSimpleFactory.h"   
107.   
108. CNokiaSimpleFactory::CNokiaSimpleFactory(void)  
109. {  
110. }  
111.   
112. CNokiaSimpleFactory::~CNokiaSimpleFactory(void)  
113. {  
114. }  
115.   
116. CNokia * CNokiaSimpleFactory::CreateNokia(const std::string & model)  
117. {  
118.     if (model == "N96")  
119.     {  
120.         return new CN96();  
121.     }  
122.     else if (model == "N95")  
123.     {  
124.         return new CN95();  
125.     }  
126.     else if (model == "N85")  
127.     {  
128.         return new CN85();  
129.     }  
130.     else if (model == "N81")  
131.     {  
132.         return new CN81();  
133.     }  
134.     else  
135.     {  
136.         assert(false);  
137.     }  
138.     return NULL;  
139. }  
140.   
141.   
142. /* main方法，可以看做客户端 */  
143. #include "stdafx.h"   
144. #include "NokiaSimpleFactory.h"   
145.   
146. int _tmain(int argc, _TCHAR* argv[])  
147. {  
148.     CNokia * nokia = NULL;  
149.         /*  
150.           modeName 可以从外部XML文件中读取，运行过程中动态的 
151.             决定该创建哪一种型号的手机 
152.          */  
153.     std::string modeName = "N96";  
154.     nokia = CNokiaSimpleFactory::CreateNokia(modeName);  
155.     nokia->MakeCall("123456789");  
156.         delete nokia;  
157.     nokia = NULL;  
158.     return 0;  
159. }