c++ 结构型模式-享元(Flyweight)

1) 意图：

运用共享技术有效的支持大量细粒度的对象。(理解享元模式，主要是对象被分解成intrinsic和extrinsic两部分，即内部的共享状态和外部状态)

2) 结构：

 

 

 其中：

1. Flyweight描述一个接口，通过这个接口Flyweight可以接受并作用于外部状态
2. ConcreteFlyweight实现Flyweight接口，并为内部状态增加存储空间
3. UnsharedConcreteFlyweight不需要共享的外部状态
4. FlyweightFactory创建并管理Flyweight对象

 3) 适用性：

1. 一个应用程序使用大量的对象
2. 完全由于使用大量的对象，造成很大的开销
3. 对象的大多数状态可以变成外部状态
4. 用相对较少的共享对象取代很多组对象
5. 应用程序不依赖于对象表示

4) 举例：

#include <iostream>
#include <list>
class  Flyweight
{
public:
    Flyweight() {}
    virtual ~Flyweight() {}
    virtual std::string getKey() { return ""; }
    virtual void  Operation(std::string extrinsicStr) = 0;
};
class  ConcreteFlyweight : public Flyweight
{
public:
    ConcreteFlyweight() {}
    ConcreteFlyweight(std::string str):m_inState(str) {}
    virtual ~ConcreteFlyweight() {}
    virtual std::string getKey() 
    {
        return m_inState;
    }
    virtual void  Operation(std::string extrinsicStr)
    {
        std::cout << extrinsicStr.c_str() << std::endl;
        std::cout << m_inState.c_str() << std::endl;
    }
private:
    std::string m_inState;
};
class FlyweightFactory
{
public:
    FlyweightFactory() {}
    virtual ~FlyweightFactory() {}
    Flyweight* GetFlyweight(std::string key)
    {
        std::list<Flyweight*>::iterator it = m_listFly.begin();
        for (; it != m_listFly.end(); ++it)
        {
            if ((*it)->getKey() == key)
            {
                return (*it);
            }
        }
        Flyweight* ptr = new ConcreteFlyweight(key);
        m_listFly.push_back(ptr);
        return ptr;
    }
private:
    std::list<Flyweight*> m_listFly;
};

 int main()
 {
     FlyweightFactory* factory = new FlyweightFactory();
     Flyweight* fly = factory->GetFlyweight("hello");
     fly->Operation("World");
     system("pause");
 }