12 结构型模式-----享元模式

模式动机(Flyweight Pattern)：顾名思义，享元模式就是运用共享技术解决大量细粒度对象的复用问题。在享元模式中，由工厂负责维护一个享元池(Flyweight Pool)，用于存储具有相同内部状态的一些对象。所谓内部状态，是指一个对象的特征，我们把大多数该类对象的不变特征确定为共享特征，将其抽象为一个类放到享元池中，对于可变的部分可以通过外部状态参数传入来解决。这样的话，如果客户要使用该类型的对象，只需通过工厂从享元池中取出即可，只有在享元池中不存在的对象才会被工厂创建出来。

 

模式结构图：

 

 

模式代码：

bt_享元模式.h：

 1 #ifndef FP_H
 2 #define FP_H
 3 #include <iostream>
 4 #include <map>
 5 using namespace std;
 6 
 7 /*
 8     抽象享元接口，用于接受外部状态
 9 */
10 class Flyweight
11 {
12 public:
13     virtual ~Flyweight(){ }
14     virtual void Operation(string extrinsicState) = 0;
15 };
16 
17 /*
18     包含共享内部状态的具体享元类
19 */
20 class ConcreteFlyweight : public Flyweight
21 {
22 public:
23     ConcreteFlyweight(){ intrinsicState = "intrinsic state"; }
24     virtual void Operation(string extrinsicState)
25     {
26         cout << "使用共享内部状态：" << intrinsicState << endl;
27         cout << "根据外部状态[ " << extrinsicState << " ]来进行工作" << endl;
28     }
29 
30 private:
31     string intrinsicState;              // 共享的内部状态
32 };
33 
34 /*
35     非共享具体享元类，其中包含了不能共享的内部状态
36 */
37 class UnsharedConcreteFlyweight : public Flyweight
38 {
39 public:
40     UnsharedConcreteFlyweight()
41     {
42         intrinsicState = "intrinsic state";
43         unSharedState = "unShared state";
44     }
45     virtual void Operation(string extrinsicState)
46     {
47         cout << "使用共享内部状态：" << intrinsicState << endl;
48         cout << "根据外部状态[ " << extrinsicState << " ]来进行工作" << endl;
49         cout << "直接使用非共享内部状态：" << unSharedState << endl;
50     }
51 
52 private:
53     string intrinsicState;         // 共享的内部状态
54     string unSharedState;          // 不能共享的内部状态
55 };
56 
57 /*
58     享元工厂类，用于创建并管理享元对象
59 */
60 class FlyweightFactory
61 {
62 public:
63     Flyweight* GetFlyweight(string key) 64     {
65         if(flyweights.find(key) == flyweights.end())
66         {
67             cout << ">>>共享池中不存在该类型的对象，正在创建中..." << endl;
68             Flyweight* fw = new ConcreteFlyweight;
69             flyweights.insert(make_pair(key, fw));
70             return fw;
71         }
72         else
73         {
74             cout << ">>>共享池中已有该类型对象，可以立即使用" << endl;
75             return flyweights[key];
76         }
77     }
78 
79 private:
80     map<string, Flyweight*> flyweights; 81 };
82 
83 #endif // FP_H

 

 

测试用例.cpp：

 1 #include "bt_享元模式.h"
 2 
 3 int main()
 4 {
 5     cout << "***** 享元模式测试 *****" << endl;
 6 
 7     cout << endl;
 8     FlyweightFactory* ff = new FlyweightFactory;
 9     Flyweight* fw = ff->GetFlyweight("benxin"); 　　　　// 第一次创建时不存在该对象
10     fw->Operation("tuzi");
11 
12     cout << endl;
13     Flyweight* fw2 = ff->GetFlyweight("benxin"); 　　　　　　// 第二次创建时直接返回该对象
14     fw2->Operation("tuzi");
15 
16 
17     cout << endl;
18     cout << "<<<直接使用非共享具体享元状态>>>" << endl; 　　　// 非共享内部状态可以直接实例化来使用 19 Flyweight* fw3 = new UnsharedConcreteFlyweight; 20     fw3->Operation("tuzi");
21 
22     delete fw3;
23     delete fw;
24     delete ff;
25 
26 　　return 0;
27 }

 

模式分析：

1>  享元模式中，选择频繁使用的类作为享元类，因为系统调用工厂也要产生时间上的开销，使用享元模式必须确保节约的空间开销是值得的；

2>  只有不会随着使用环境改变的状态才可以被设为共享状态；有些状态虽为内部状态，但是并不适合共享，对于这类状态，客户可以越过工厂直接实例化进行使用。

3>  享元模式的使用情况主要存在于系统中需要重复使用相同或类似的对象，如果每次都重复创建，可能会消耗大量内存空间，比如，文档编辑器中的字符类就适合作为享元类，而字符的位置参数适合作为外部状态使用，这样就可以加快文档的处理速度。