享元模式运用共享技术有效地支持大量细粒度的对象。
UML图如下：
C++代码实现如下：
#include <iostream> #include <cstring> using namespace std; /* Flyweight类，它是所有具体享元类的 超类或接口，通过这个接口，Flyweight 可以接受并作用于外部状态 */ class Flyweight { public: char name[10]; virtual void Operation(int) = 0; }; /* ConcreteFlyweight是继承了Flyweight超类或实现 Flyweight接口，并为内部状态增加存储空间 */ class ConcreteFlyweight : public Flyweight { public: void Operation(int extrinsicstate) { cout <<"具体Flyweight_" << name <<":" << extrinsicstate << endl; } }; /* UnsharedConcreteFlyweight是指那些不需要共享的 Flyweight子类。因为Flyweight接口共享成为可能 但它不强制共享 */ class UnsharedConcreteFlyweight : public Flyweight { public: UnsharedConcreteFlyweight(char * str) { strcpy(name, str); } void Operation(int extrinsicstate) { cout << "不共享的具体Flyweight_" << name <<":" << extrinsicstate << endl; } }; /* node 节点 */ struct node { node * next[26]; Flyweight * pFlyweight; }; /* 自己写的伪map */ class MyMap { private: node * root; public: MyMap(); node * getNode(); void insert(char * str, Flyweight * pFlyweight); Flyweight * query(char * str); }; node * MyMap::getNode() { node * pNode = (node *)malloc(sizeof(node)); pNode->pFlyweight = NULL; memset(pNode->next, 0, sizeof(pNode->next)); return pNode; } MyMap::MyMap() { root = getNode(); } void MyMap::insert(char * str, Flyweight * pFlyweight) { node * pCur = root; int len = strlen(str); for (int i = 0; i < len; ++i) { int index = str[i] - 'a'; if (pCur->next[index] == NULL) { pCur->next[index] = getNode(); } pCur = pCur->next[index]; } pCur->pFlyweight = pFlyweight; strcpy(pCur->pFlyweight->name, str); } Flyweight * MyMap::query(char * str) { node * pCur = root; int len = strlen(str); for (int i = 0; i < len; ++i) { int index = str[i] - 'a'; if (pCur->next[index] == NULL) { return NULL; } pCur = pCur->next[index]; } return pCur->pFlyweight; } /* FlyweightFactory是一个享元工厂，用来创建并 管理Flyweight对象，它主要是用来确保合理地 共享Flyweight对象提供一个已创建的实例或者 创建一个（如果不存在） */ class FlyweightFactory { private: MyMap map; public: FlyweightFactory() { map.insert("x", new ConcreteFlyweight()); map.insert("y", new ConcreteFlyweight()); map.insert("z", new ConcreteFlyweight()); } Flyweight * getFlyweight(char * str) { return map.query(str); } }; int main() { //代码外部状态 int extrinsicstate = 22; FlyweightFactory factory; Flyweight * pFx = factory.getFlyweight("x"); pFx->Operation(--extrinsicstate); Flyweight * pFy= factory.getFlyweight("y"); pFy->Operation(--extrinsicstate); Flyweight * pFz = factory.getFlyweight("z"); pFz->Operation(--extrinsicstate); Flyweight * pUnsharedF = new UnsharedConcreteFlyweight("u"); pUnsharedF->Operation(--extrinsicstate); return 0; }
思考：Flyweight根据客户需求返回已经生成好的对象，但一定要事先生成对象实例吗？
答：实际上是不一定需要的，完全可以初始化的时候什么也不做，到需要的时候，再去判断对象是否为NULL来决定是否实例化。
思考：为什么要有UnsharedConcreteFlyweight的存在呢？
答：因为尽管我们大部分时间都需要共享对象来降低内存的消耗，但个别时候也有可能不需要共享的，那么此时的UnsharedConcreteFlyweight子类就有存在的必要了，它可以解决那些不需要共享对象的问题。
*内部状态和外部状态
在享元对象内部并且不会随环境改变而改变的共享部分，可以称为是享元对象的内部状态；而随着环境变化而变化的不可共享的状态就是说外部状态了。事实上，享元模式可以避免大量非常相似类的开销。在程序设计中，有时需要生成大量细粒度的类实例来表示数据。如果能发现这些实例除了几个参数外基本上都是相同的，有时就能够大幅度地减小需要实例化的类的数量。如果能把那些参数移到类实例的外面，在方法调用时将它们传递过来，就可以通过共享大幅度地减少单个实例的数目。也就是说，享元模式Flyweight执行时所需的状态是有内部的也有可能有外部状态的，内部状态存储在ConcreteFlyweight中，而对象的外部状态考虑有客户端对象存储或计算，当调用Flyweight对象的操作时，将该状态传递给它。
享元模式的应用
*什么时候使用享元模式？
答：如果一个应用程序使用了大量的对象，而大量的这些对象造成了很大的存储开销时就应该考虑使用；还有就是对象的大多数状态可以是外部状态，如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象，此时可以考虑使用享元模式。
