Flyweight Pattern

1.Flyweight 模式以共享的方式高效的支持大量的细粒度对象，对象分为内部状态、外部状态。将可以被共享的状态作为内部状态存储在对象中，而外部状态在适当的时候作为参数传递给对象。

当以下所有的条件都满足时，可以考虑使用享元模式：

• 一个系统有大量的对象。
• 这些对象耗费大量的内存。
• 这些对象的状态中的大部分都可以外部化。
• 这些对象可以按照内蕴状态分成很多的组，当把外蕴对象从对象中剔除时，每一个组都可以仅用一个对象代替。
• 软件系统不依赖于这些对象的身份，换言之，这些对象可以是不可分辨的。

2.Flyweight模式结构图（不想被共享的对象UnshaerConcreteFlyweight，暂不讨论）

3.实现

 1 #ifndef _FLYWEIGHT_H_ 
 2 #define _FLYWEIGHT_H_
 3 
 4 #include <string> 
 5 using namespace std;
 6 
 7 class Flyweight 
 8 { 
 9 public:
10     virtual ~Flyweight();
11     virtual void Operation(const string& extrinsicState);
12     string GetIntrinsicState();
13 protected: 
14     Flyweight(string intrinsicState);
15 private: 
16     string _intrinsicState;
17 };
18 
19 class ConcreteFlyweight:public Flyweight 
20 { 
21 public: 
22     ConcreteFlyweight(string intrinsicState);
23     ~ConcreteFlyweight();
24     void Operation(const string& extrinsicState);
25 protected:
26 private: 
27 }; 
28 
29 #endif

Flyweight.h

 1 #include "Flyweight.h" 
 2 #include <iostream> 
 3 using namespace std;
 4 
 5 Flyweight::Flyweight(string intrinsicState) 
 6 { 
 7     this->_intrinsicState = intrinsicState;
 8 }
 9 Flyweight::~Flyweight() 
10 {
11 
12 }
13 void Flyweight::Operation(const string& extrinsicState) 
14 {
15 
16 }
17 string Flyweight::GetIntrinsicState() 
18 { 
19     return this->_intrinsicState; 
20 }
21 ConcreteFlyweight::ConcreteFlyweight(string intrinsicState):Flyweight(intrinsicState) 
22 { 
23     cout<<"ConcreteFlyweight Build....."<<intrinsicState<<endl;
24 }
25 ConcreteFlyweight::~ConcreteFlyweight() 
26 {
27 
28 }
29 void ConcreteFlyweight::Operation(const string& extrinsicState) 
30 { 
31     cout<<"ConcreteFlyweight:内蕴["<<this->GetIntrinsicState()<<"] 外蕴["<<extrinsicState<<"]"<<endl; 
32 }

Flyweight.cpp

 1 #ifndef _FLYWEIGHTFACTORY_H_
 2 #define _FLYWEIGHTFACTORY_H_
 3 
 4 #include "Flyweight.h" 
 5 #include <string> 
 6 #include <vector> 
 7 using namespace std;
 8 
 9 class FlyweightFactory 
10 { 
11 public: 
12     FlyweightFactory();
13     ~FlyweightFactory();
14     Flyweight* GetFlyweight(const string& key);
15 protected:
16 private: 
17     vector<Flyweight*> _fly;
18 }; 
19 
20 #endif

FlyweightFactory.h

 1 #include "FlyweightFactory.h" 
 2 #include <iostream> 
 3 #include <string> 
 4 #include <cassert> 
 5 using namespace std;
 6 using namespace std;
 7 
 8 FlyweightFactory::FlyweightFactory()
 9 {
10 
11 }
12 FlyweightFactory::~FlyweightFactory() 
13 {
14 
15 }
16 Flyweight* FlyweightFactory::GetFlyweight(const string& key)
17 { 
18     vector<Flyweight*>::iterator it = _fly.begin();
19     for (; it != _fly.end();it++) 
20     { //找到了，就一起用，^_^ 
21         if ((*it)->GetIntrinsicState() == key) 
22         { 
23             cout<<"already created by users...."<<endl;
24             return *it; 
25         } 
26     }
27     Flyweight* fn = new ConcreteFlyweight(key);
28     _fly.push_back(fn);
29     return fn; 
30 }

FlyweightFactory.cpp

 1 #include "Flyweight.h" 
 2 #include "FlyweightFactory.h" 
 3 #include <iostream> 
 4 using namespace std;
 5 
 6 int main(int argc,char* argv[]) 
 7 { 
 8     FlyweightFactory* fc = new FlyweightFactory();
 9     Flyweight* fw1 = fc->GetFlyweight("hello"); 
10     Flyweight* fw2 = fc->GetFlyweight("world!");
11     Flyweight* fw3 = fc->GetFlyweight("hello");
12     return 0; 
13 }

main.cpp