C++与模式－－－简单工厂模式(Simple Factory Pattern)

C++中的简单工厂模式


在C++程序设计中，也许你想设计出一套自已的类库出来，为别人或自已的程序所用，类库的设计如果能够合理地用上设计模式的思想，则会使之易用性大大提高。本文就来探讨探讨C++中一个比较基础的设计模式的使用：简单工厂模式，也称作静态工厂方法模式。

简单工厂模式讲的是类的对象或称实例的创建模式，我们来看一个实例:
假如你要设计一个图形系统库，当然这里很简单了，呵呵，在这个库中只有两个图形元素，长方形（Rectangle)和圆形（Circle).
首先，对于这两种图形我们可以抽象出它的们共同部分成为它们的基类（Shape)，说出shape，也许您会觉得它很抽象，不知道它到底是什么玩艺儿。那好，我们就把它弄成抽象类好了：

1. class Shape
2. {
3.     public:
4.         virtual void setColor()=0;//设置颜色
5.         virtual void introduce()=0;//自我介绍
6. };
7. 
   

也许您又要问，为什么要把这两个方法整成纯虚的呢？得，那是因为shape太抽象呀!所以把它的方法弄成虚的，这样，它就起到了一个决定它的子类必须具备的功能的作用，只有实现了这两个方法的类才能成为它的子类。这样一来的好处就是无论是圆还是长方形，它们都可以被看做Shape，当成Shape一样来处理。你完全可以使用一个Shape*型的指针来指向一个Circle或Rectangle型的对象，然后通过这个指针调用这两个方法。OK，闲话少说，咱们继续。
接下来我们定义这两个图形：

1. class Rectangle : public Shape
2. {
3.     public:
4.         virtual void setColor()
5.         {
6.             cout<<"set rectangle color"<<endl;
7.         }
8.         virtual void introduce()
9.         {
10.             cout<<"Hello, I am a rectangle, nice to meet you."<<endl;
11.         }
12. };
13. class Circle : public Shape
14. {
15.     public:
16.         virtual void setColor()
17.         {
18.             cout<<"set circle color"<<endl;
19.         }
20.         virtual void introduce()
21.         {
22.             cout<<"Hello, I am a circle, nice to meet you."<<endl;
23.         }
24. };

这些代码很平常，没有什么值得关注的地方，然后我们的主角上场了，那就是大名鼎鼎的图形工厂(ShapeFactory)，HERE IT COMES:

1. class ShapeFactory
2. {
3.         static Shape *createShape(string str)                                
4.         {  
5.             if(str == "circle")                                       
6.             {  
7.                 return new Circle();                                  
8.             }
9.             else if(str == "rectangle")                               
10.             {  
11.                 return new Rectangle();                               
12.             }
13.             else                                                      
14.             {  
15.                 return NULL;                                          
16.             }                                                         
17.         } 
18. }                               

看到它里面的那个static， 你就明白为什么叫静态工厂方法模式了，这个工厂会根据客户程序的需求来制造指定的图形，而客户却不需要知道具体图形的创建过程及细节，这里所说的客户就是马上要上场的main函数：

1. int main(int argc, char** argv)
2. {
3.     Shape *rect = ShapeFactory::createShape("rectangle")
4.     
5.     Shape   *cir = ShapeFactory::createShape("circle");
6. 
   
7.     Shape *shape_array[2] = {rect, cir};
8. 
   
9.     for(int i = 0; i < 2; i++)
10.     {
11.         (shape_array[i])->introduce();
12.         (shape_array[i])->setColor();
13.     }
14.     return 0;
15. }

在客户看来，它只知道这个世界上有正方形与圆形这两种图形，但它把它们统统看成是Shape，因为它们不必要去亲自创建具体是那个图形，图形工厂帮它们完成这一切，所以在main中你看不到有Rectangle类名出现，同时，这种抽象会带来另一个很大的好处，那就是，这两种不同的图形，可以被放在数组中统一处理，这就是我们建立虚基类Shape的好处。

当你要新增加图形类型的时侯，客户端基本不受影响，因为它只需要知道有Shape可以被创建，同时，有Factory可以为它创建Shape就行了。呵呵，是不是有点认识了？

完整代码如下,在 Fedora Core 9上运行通过：

1. #include <iostream>
2. #include <stdio.h>
3. #include <string.h>
4. using namespace std;
5. class Shape
6. {
7. 
   
8.     public:
9.         virtual void setColor()=0;
10.         virtual void introduce()=0;
11. };
12. class Rectangle : public Shape
13. {
14.     public:
15.         virtual void setColor()
16.         {
17.             cout<<"set rectangle color"<<endl;
18.         }
19.         virtual void introduce()
20.         {
21.             cout<<"Hello, I am a rectangle, nice to meet you."<<endl;
22.         }
23. };
24. class Circle : public Shape
25. {
26.     public:
27.         virtual void setColor()
28.         {
29.             cout<<"set circle color"<<endl;
30.         }
31.         virtual void introduce()
32.         {
33.             cout<<"Hello, I am a circle, nice to meet you."<<endl;
34.         }
35. };
36. class ShapeFactory
37. {
38.     public:
39.         static Shape *createShape(string str)
40.         {
41.             if(str == "circle")
42.             {
43.                 return new Circle();
44.             }
45.             else if(str == "rectangle")
46.             {
47.                 return new Rectangle();
48.             }
49.             else
50.             {
51.                 return NULL;
52.             }
53.         }
54. };
55. 
    
56. 
    
57. int main(int argc, char** argv)
58. {
59.     Shape *rect = ShapeFactory::createShape("rectangle");
60.     Shape   *cir = ShapeFactory::createShape("circle");
61.     Shape *shape_array[2] = {rect, cir};
62.     for(int i = 0; i < 2; i++)
63.     {
64.         (shape_array[i])->introduce();
65.         (shape_array[i])->setColor();
66.     }
67.     return 0;
68. }
69. 
    
70.