flyweight模式

Flyweight模式

一.意图

运用共享技术有效地支持大量细粒度的对象

二.适用性

1.    一个应用程序使用了大量的对象

2.    完全由于使用大量的对象,造成很大的存储开销

3.    对象的大多数状态都可变为外部状态

4.    如果删除对象的外部状态,那么可以用相对较少的共享对象取代很多组对象

5.    应用程序不依赖对象标识,由于flyweight对象可以被共享,对于概念上明显有别的对象,标识测试将返回真值.

三.结构

 

 

 

四.代码

#include<iostream>

#include<stdio.h>

#include<stdlib.h>

#include<vector>

usingnamespacestd;

//flyweightmode

//内部状态:类型

enumenFruitType

{

    TYPE_NULL=0,

    TYPE_APPLE,

    TYPE_BANANA,

    TYPE_ORANGE,

};

//flyweight

classCFlyWeight

{

public:

    virtualvoidOperation(stringname){}

    //获取内部状态

    virtualenFruitTypeGetIntrinsicState(){}

 

protected:

    enFruitTypem_fruitType=TYPE_NULL;

};

 

//具体亨元模式

classCConcreteFlyWeight:publicCFlyWeight

{

public:

    CConcreteFlyWeight(enFruitTypefruitType)

    {

        this->m_fruitType=fruitType;

    }

 

    virtualenFruitTypeGetIntrinsicState()

    {

        returnm_fruitType;

    }

 

    virtualvoidOperation(stringname)

    {

        stringbuyName=name;

        cout<<buyName<<"buyfruit"<<m_fruitType<<endl;

    }

};

 

//不共享的具体亨元,客户端直接调用

classCUnsharedConcreteFlyweight:publicCFlyWeight

{

public:

    virtualvoidOperation(stringname)

    {

        CFlyWeight*flyweight=NULL;

        for(inti=0;i<m_pvecFactory.size();i++)

        {

            flyweight=newCConcreteFlyWeight(m_pvecFactory[i]);

            flyweight->Operation(name);

        }

    }

 

    voidadd(enFruitTypetype)

    {

        this->m_pvecFactory.push_back(type);

    }

private:

    vector<enFruitType>m_pvecFactory;

};

 

classCFlyweightFactory

{

public:

//1.复合亨元模式,不共享内部状态

    CUnsharedConcreteFlyweight*GetFlyweight(vector<enFruitType>compositeState){

        CUnsharedConcreteFlyweight*compositeFlyweight=newCUnsharedConcreteFlyweight();

        for(inti=0;i<compositeState.size();i++)

        {

            compositeFlyweight->add(compositeState[i]);

        }

        returncompositeFlyweight;

    }

 

//2.单纯亨元模式,共享内部状态

    CFlyWeight*GetFlyweight(enFruitTypetype)

    {

        for(inti=0;i<m_pvecFactory.size();i++)

        {

            if(m_pvecFactory[i]->GetIntrinsicState()==type)

            {

                returnm_pvecFactory[i];

            }

        }

        CFlyWeight*flyweight=newCConcreteFlyWeight(type);

        this->m_pvecFactory.push_back(flyweight);

        returnflyweight;

    }

 

    voidGetFlyweightCount()

    {

        cout<<"num="<<this->m_pvecFactory.size()<<endl;

    }

 

private:

    vector<CFlyWeight*>m_pvecFactory;

};

 

intmain()

{

    cout<<"HelloWorld!"<<endl;

    cout<<"1.----------------------------------------"<<endl;

//    CFlyweightFactory*factory=newCFlyweightFactory();

//    CFlyWeight*flyweight=factory->GetFlyweight(TYPE_APPLE);

//    CFlyWeight*flyweight1=factory->GetFlyweight(TYPE_APPLE);

//    CFlyWeight*flyweight2=factory->GetFlyweight(TYPE_BANANA);

//    flyweight->Operation("Tom");

//    flyweight1->Operation("Black");

//    flyweight2->Operation("Jack");

//    factory->GetFlyweightCount();

 

    cout<<"2.----------------------------------------"<<endl;

    vector<enFruitType>compositeState;

    compositeState.push_back(TYPE_APPLE);

    compositeState.push_back(TYPE_BANANA);

    compositeState.push_back(TYPE_ORANGE);

    compositeState.push_back(TYPE_APPLE);

 

    CFlyweightFactory*factory=newCFlyweightFactory();

    CFlyWeight*flyweight=factory->GetFlyweight(compositeState);

    CFlyWeight*flyweight1=factory->GetFlyweight(compositeState);

    flyweight->Operation("Composite");

    flyweight1->Operation("Composite1");

 

    return0;

}