Flyweight Pattern

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

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

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

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

3.实现

#ifndef _FLYWEIGHT_H_ 
#define _FLYWEIGHT_H_

#include <string> 
using namespace std;

class Flyweight 
{ 
public:
    virtual ~Flyweight();
    virtual void Operation(const string& extrinsicState);
    string GetIntrinsicState();
protected: 
    Flyweight(string intrinsicState);
private: 
    string _intrinsicState;
};

class ConcreteFlyweight:public Flyweight 
{ 
public: 
    ConcreteFlyweight(string intrinsicState);
    ~ConcreteFlyweight();
    void Operation(const string& extrinsicState);
protected:
private: 
}; 

#endif

#include "Flyweight.h" 
#include <iostream> 
using namespace std;

Flyweight::Flyweight(string intrinsicState) 
{ 
    this->_intrinsicState = intrinsicState;
}
Flyweight::~Flyweight() 
{

}
void Flyweight::Operation(const string& extrinsicState) 
{

}
string Flyweight::GetIntrinsicState() 
{ 
    return this->_intrinsicState; 
}
ConcreteFlyweight::ConcreteFlyweight(string intrinsicState):Flyweight(intrinsicState) 
{ 
    cout<<"ConcreteFlyweight Build....."<<intrinsicState<<endl;
}
ConcreteFlyweight::~ConcreteFlyweight() 
{

}
void ConcreteFlyweight::Operation(const string& extrinsicState) 
{ 
    cout<<"ConcreteFlyweight:内蕴["<<this->GetIntrinsicState()<<"] 外蕴["<<extrinsicState<<"]"<<endl; 
}

#ifndef _FLYWEIGHTFACTORY_H_
#define _FLYWEIGHTFACTORY_H_

#include "Flyweight.h" 
#include <string> 
#include <vector> 
using namespace std;

class FlyweightFactory 
{ 
public: 
    FlyweightFactory();
    ~FlyweightFactory();
    Flyweight* GetFlyweight(const string& key);
protected:
private: 
    vector<Flyweight*> _fly;
}; 

#endif

#include "FlyweightFactory.h" 
#include <iostream> 
#include <string> 
#include <cassert> 
using namespace std;
using namespace std;

FlyweightFactory::FlyweightFactory()
{

}
FlyweightFactory::~FlyweightFactory() 
{

}
Flyweight* FlyweightFactory::GetFlyweight(const string& key)
{ 
    vector<Flyweight*>::iterator it = _fly.begin();
    for (; it != _fly.end();it++) 
    { //找到了，就一起用，^_^ 
        if ((*it)->GetIntrinsicState() == key) 
        { 
            cout<<"already created by users...."<<endl;
            return *it; 
        } 
    }
    Flyweight* fn = new ConcreteFlyweight(key);
    _fly.push_back(fn);
    return fn; 
}

#include "Flyweight.h" 
#include "FlyweightFactory.h" 
#include <iostream> 
using namespace std;

int main(int argc,char* argv[]) 
{ 
    FlyweightFactory* fc = new FlyweightFactory();
    Flyweight* fw1 = fc->GetFlyweight("hello"); 
    Flyweight* fw2 = fc->GetFlyweight("world!");
    Flyweight* fw3 = fc->GetFlyweight("hello");
    return 0; 
}