设计模式之享元模式

1、享元模式运用共享技术有效地支持大量细粒度的对象。

UML图如下：

2、思考：Flyweight根据客户需求返回已经生成好的对象，但一定要事先生成对象实例吗？

答：实际上是不一定需要的，完全可以初始化的时候什么也不做，到需要的时候，再去判断对象是否为NULL来决定是否实例化。

3、思考：为什么要有UnsharedConcreteFlyweight的存在呢？

答：因为尽管我们大部分时间都需要共享对象来降低内存的消耗，但个别时候也有可能不需要共享的，那么此时的UnsharedConcreteFlyweight子类就有存在的必要了，它可以解决那些不需要共享对象的问题。

4、内部状态和外部状态

在享元对象内部并且不会随环境改变而改变的共享部分，可以称为是享元对象的内部状态；而随着环境变化而变化的不可共享的状态就是说外部状态了。

事实上，享元模式可以避免大量非常相似类的开销。在程序设计中，有时需要生成大量细粒度的类实例来表示数据。如果能发现这些实例除了几个参数外基本上都是相同的，有时就能够大幅度地减小需要实例化的类的数量。如果能把那些参数移到类实例的外面，在方法调用时将它们传递过来，就可以通过共享大幅度地减少单个实例的数目。

也就是说，享元模式Flyweight执行时所需的状态是有内部的也有可能有外部状态的，内部状态存储在ConcreteFlyweight中，而对象的外部状态考虑有客户端对象存储或计算，当调用Flyweight对象的操作时，将该状态传递给它。

5、享元模式的应用：什么时候使用享元模式？

答：如果一个应用程序使用了大量的对象，而大量的这些对象造成了很大的存储开销时就应该考虑使用；还有就是对象的大多数状态可以是外部状态，如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象，此时可以考虑使用享元模式。

[cpp] view plaincopy

1. #include <iostream>  
2. #include <cstring>  
3. using namespace std;  
4. 
   
5. /* Flyweight类，它是所有具体享元类的 
6.     超类或接口，通过这个接口，Flyweight 
7.     可以接受并作用于外部状态 */  
8. class Flyweight  
9. {  
10. public:  
11.     char name[10];  
12.     virtual void Operation(int) = 0;  
13. };  
14. /*  ConcreteFlyweight是继承了Flyweight超类或实现 
15.     Flyweight接口，并为内部状态增加存储空间 */  
16. class ConcreteFlyweight : public Flyweight  
17. {  
18. public:  
19.     void Operation(int extrinsicstate)   
20.     {  
21.         cout <<"具体Flyweight_" << name <<":" << extrinsicstate << endl;  
22.     }  
23. };  
24. /*  UnsharedConcreteFlyweight是指那些不需要共享的 
25.     Flyweight子类。因为Flyweight接口共享成为可能 
26.     但它不强制共享 */  
27. class UnsharedConcreteFlyweight : public Flyweight  
28. {  
29. public:  
30.     UnsharedConcreteFlyweight(char * str)   
31.     {  
32.         strcpy(name, str);  
33.     }  
34.       
35.     void Operation(int extrinsicstate)   
36.     {  
37.         cout << "不共享的具体Flyweight_" << name <<":" << extrinsicstate << endl;  
38.     }  
39. };  
40. /*  node 节点 */  
41. struct node   
42. {  
43.     node * next[26];  
44.     Flyweight * pFlyweight;  
45. };  
46. /*  自己写的伪map */  
47. class MyMap  
48. {  
49. private:  
50.     node * root;  
51. public:  
52.     MyMap();  
53.     node * getNode();  
54.     void insert(char * str, Flyweight * pFlyweight);  
55.     Flyweight * query(char * str);  
56. };  
57. node * MyMap::getNode() {  
58.     node * pNode = (node *)malloc(sizeof(node));  
59.     pNode->pFlyweight = NULL;  
60.     memset(pNode->next, 0, sizeof(pNode->next));  
61.     return pNode;  
62. }  
63. MyMap::MyMap()   
64. {  
65.     root = getNode();  
66. }  
67. void MyMap::insert(char * str, Flyweight * pFlyweight)   
68. {  
69.     node * pCur = root;  
70.     int len = strlen(str);  
71.     for (int i = 0; i < len; ++i)   
72.     {  
73.         int index = str[i] - 'a';  
74.         if (pCur->next[index] == NULL)   
75.         {  
76.             pCur->next[index] = getNode();  
77.         }  
78.         pCur = pCur->next[index];  
79.     }  
80.     pCur->pFlyweight = pFlyweight;  
81.     strcpy(pCur->pFlyweight->name, str);  
82. }  
83. Flyweight * MyMap::query(char * str)   
84. {  
85.     node * pCur = root;  
86.     int len = strlen(str);  
87.     for (int i = 0; i < len; ++i)  
88.     {  
89.         int index = str[i] - 'a';  
90.         if (pCur->next[index] == NULL)   
91.         {  
92.             return NULL;  
93.         }   
94.         pCur = pCur->next[index];  
95.     }  
96.     return pCur->pFlyweight;  
97. }  
98. /* 
99.     FlyweightFactory是一个享元工厂，用来创建并 
100.     管理Flyweight对象，它主要是用来确保合理地 
101.     共享Flyweight对象提供一个已创建的实例或者 
102.     创建一个（如果不存在） 
103.  */  
104. class FlyweightFactory  
105. {  
106. private:  
107.     MyMap map;  
108. public:  
109.     FlyweightFactory()   
110.     {  
111.         map.insert("x", new ConcreteFlyweight());  
112.         map.insert("y", new ConcreteFlyweight());  
113.         map.insert("z", new ConcreteFlyweight());  
114.     }  
115.       
116.     Flyweight * getFlyweight(char * str)   
117.     {  
118.         return map.query(str);  
119.     }  
120. };  
121. int main()  
122. {  
123.     //代码外部状态  
124.     int extrinsicstate = 22;  
125.     FlyweightFactory factory;  
126.     Flyweight * pFx = factory.getFlyweight("x");  
127.     pFx->Operation(--extrinsicstate);  
128.     Flyweight * pFy= factory.getFlyweight("y");  
129.     pFy->Operation(--extrinsicstate);  
130.     Flyweight * pFz = factory.getFlyweight("z");  
131.     pFz->Operation(--extrinsicstate);  
132.     Flyweight * pUnsharedF = new UnsharedConcreteFlyweight("u");  
133.     pUnsharedF->Operation(--extrinsicstate);  
134.     return 0;  
135. }