C++设计模式之二:AbstractFactory Pattern

AbstractFactory模式就是用来解决这类问题的：要创建一组相关或者相互依赖的对象。

 

AbstractFactory模式关键就是将这一组对象的创建封装到一个用于创建对象的（ConcreteFactory）中，维护这样一个创建类总比维护n多相关对象的创建过程要简单的多。

 

AbstractFactory模式典型的结构图为：

 

代码如下:

2. //AbstractProduct.h
5. #ifndef _ABSTRACTPRODUCT_H_
6. #define _ABSTRACTPRODUCT_H_
8. class AbstractProductA
9. {
10. public:
11.     virtual ~AbstractProductA();
12. protected:
13.     AbstractProductA(); 
14. };
16. class AbstractProductB
17. {
18. public:
19.     virtual ~AbstractProductB();
20. protected:
21.     AbstractProductB();
22. };
24. class ProductA1:public AbstractProductA
25. {
26. public:
27.     ~ProductA1();
28.     ProductA1();
29. };
31. class ProductA2:public AbstractProductA
32. {
33. public:
34.     ~ProductA2();
35.     ProductA2();
36. };
38. class ProductB1:public AbstractProductB
39. {
40. public:
41.     ~ProductB1();
42.     ProductB1();
43. };
45. class ProductB2:public AbstractProductB
46. {
47. public:
48.     ~ProductB2();
49.     ProductB2();
50. };
51. #endif
53. //AbstractractProduct.cpp
54. #include "AbstractProduct.h"
55. #include <iostream.h>
57. AbstractProductA::AbstractProductA()
58. {
60. }
61. AbstractProductA::~AbstractProductA()
62. {
64. }
66. AbstractProductB::AbstractProductB()
67. {
69. }
71. AbstractProductB::~AbstractProductB()
72. {
74. }
76. ProductA1::~ProductA1()
77. {
79. }
81. ProductA1::ProductA1()
82. {
83.     cout<<"Constructing ProductA1..."<<endl;
84. }
86. ProductA2::~ProductA2()
87. {
89. }
91. ProductA2::ProductA2()
92. {
93.     cout<<"Constructing ProductA2..."<<endl;
94. }
96. ProductB1::~ProductB1()
97. {
99. }
101. ProductB1::ProductB1()
102. {
103.     cout<<"Constructing ProductB1"<<endl;
104. }
106. ProductB2::~ProductB2()
107. {
109. }
111. ProductB2::ProductB2()
112. {
113.     cout<<"Constructing ProductB2..."<<endl;
114. }
116. //AbstractFactory.h
117. #ifndef _ABSTRACTFACTORY_H_
118. #define _ABSTRACTFACTORY_H_
120. class AbstractProductA;
121. class AbstractProductB;
123. class AbstractFactory
124. {
125. public:
126.     virtual ~AbstractFactory();
127.     virtual AbstractProductA* createProductA()=0;
128.     virtual AbstractProductB* createProductB()=0;
129. protected:
130.     AbstractFactory();
131. };
133. class ConcreteFactory1:public AbstractFactory
134. {
135. public:
136.     ConcreteFactory1();
137.     ~ConcreteFactory1();
138.     AbstractProductA* createProductA();
139.     AbstractProductB* createProductB(); 
140. };
142. class ConcreteFactory2:public AbstractFactory
143. {
144. public:
145.     ConcreteFactory2();
146.     ~ConcreteFactory2();
147.     AbstractProductA* createProductA();
148.     AbstractProductB* createProductB();     
149. };
151. #endif
153. //AbstractFactory.cpp
154. #include "AbstractFactory.h"
155. #include "AbstractProduct.h"
157. AbstractFactory::AbstractFactory()
158. {
160. }
162. AbstractFactory::~AbstractFactory()
163. {
165. }
167. ConcreteFactory1::ConcreteFactory1()
168. {
170. }
172. ConcreteFactory1::~ConcreteFactory1()
173. {
175. }
177. ConcreteFactory2::ConcreteFactory2()
178. {
180. }
182. ConcreteFactory2::~ConcreteFactory2()
183. {
185. }
187. AbstractProductA* ConcreteFactory1::createProductA()
188. {
189.     return new ProductA1();
190. }
192. AbstractProductB* ConcreteFactory1::createProductB()
193. {
194.     return new ProductB1();
195. }
197. AbstractProductA* ConcreteFactory2::createProductA()
198. {
199.     return new ProductA2();
200. }
202. AbstractProductB* ConcreteFactory2::createProductB()
203. {
204.     return new ProductB2();
205. }

         AbstractFactory模式和Factory模式的区别是初学（使用）设计模式时候的一个容易引起困惑的地方。实际上，AbstractFactory模式是为创建一组（有多类）相关或依赖的对象提供创建接口，而Factory模式正如我在相应的文档中分析的是为一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到，AbstractFactory模式通常都是使用Factory模式实现（ConcreteFactory1）。