flyweight pattern -- 享元模式

来源：互联网发布：mac 键盘控制声音编辑：程序博客网时间：2024/05/22 08:27

flyweight pattern -- 享元模式

分类：设计模式2013-01-09 10:03 257人阅读评论(6) 收藏举报

设计模式

内部状态与外部状态：  分离变与不变，共享不变，用接口实现 变化；

flyweight pattern 又称享元模式

Use sharing to support large numbers of fine-grained objects efficiently --- GoF

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

UnshareConcreteFlyweight:
并不是所有的Flyweight具体实现子类都需要被共享的，如果是不能共享的，那么就只能是它只能被引用一个。
ConcreteFlyweight:
可以被共享，该对象可以被多个引用。
还是以汽车模型为例子，例如我们来建立一个跑车的部分场景，每个赛车都有轮胎，外壳，品牌，引擎
这个部分组成，轮胎影响飘逸和刹车的效果，外壳仅仅是外观效果，引擎影响最大速度和加速度，品牌影响可以被撞后影响。我们游戏会有40辆车，如果构建这20辆车需要160个对象，但是我们发现这160个对象太消耗系统性能与资源了，其实有些对象是一样的的，那么在这个场景中，完全可以共享这些对象，那么这样
可以节省好多对象的构造与析构，系统牺牲一定空间来提升性能与效率。
轮胎有：米其林，普利司通两种轮胎
Michelin轮胎：摩擦系数很高，漂移效果好，损耗很高
Bridgestone轮胎：摩擦细数一般，漂移效果一般，损耗一般
外壳有：红色，黑色，白色，蓝色，绿色，黄色，紫色七种
品牌有：宝马，法拉利，奥迪，奔驰四种
BMW：坚固性强，被撞减速一般
Ferrari: 坚固性弱，被减速大
Audi:坚固性一般，被减速大
Benz：坚固性一般，被减速小
引擎：法拉利研制，红牛研制，奔驰研制，宝马研制
Ferrari:速度高，加速高
Redbull:速度高，加速一般
Benz:速度一般，加速一般
BMW:速度一般，加速快

模拟从数据库或者配置表里获得数据
function.h文件

[cpp] view plaincopy
#include <iostream>  
float getFriction(std::string wheelname);  
float getDrifting(std::string wheelname);  
float getPorperty(std::string wheelname);  
int getPamer(std::string brandname);  
float getEffect(std::string brandname);  
int getMaxSpeed(std::string makename);  
int getAcceleration(std::string makename);  
function.cpp文件

[cpp] view plaincopy
#include "function.h"   
float getFriction(std::string wheelname)  
{  
    if(wheelname=="Michelin")return 240;  
    else if(wheelname=="Bridgestone")return 200;  
    else return -1;  
}  
  
float getDrifting(std::string wheelname)  
{  
    if(wheelname=="Michelin")return 100;  
    else if(wheelname=="Bridgestone")return 80;  
    else return -1;  
}  
  
float getPorperty(std::string wheelname)  
{  
    if(wheelname=="Michelin")return 0.03;  
    else if(wheelname=="Bridgestone")return 0.02;  
    else return -1;  
}  
  
int getPamer(std::string brandname)  
{  
    if(brandname=="BMW") return 3;  
    else if(brandname=="Ferrari")return 1;  
    else if(brandname=="Benz")return 2;  
    else if(brandname=="Audi")return 2;  
    else return -1;  
}  
  
float getEffect(std::string brandname)  
{  
    if(brandname=="BMW")return 0.8;  
    else if(brandname=="Ferrari") return 0.4;  
    else if(brandname=="Benz")return 0.6;  
    else if(brandname=="Audi")return 0.6;  
    else return -1;  
}  
  
int getMaxSpeed(std::string makename)  
{  
    if(makename=="BMW")return 400;  
    else if(makename=="Benz")return 400;  
    else if(makename=="Ferrari") return 500;  
    else if(makename=="redBull") return 480;  
    else return -1;  
}  
  
int getAcceleration(std::string makename)  
{  
    if(makename=="BMW")return 9;  
    else if(makename=="Ferrari")return 10;  
    else if(makename=="Benz") return 8;  
    else if(makename=="redBull")return 8;  
    else return -1;  
}  
flyweight.cpp

[cpp] view plaincopy
#include <utility>  
#include <map>  
#include "function.h"  
  
class wheel  
{  
    public:  
        wheel(std::string n,float f,float d,float p)  
        :name(n),friction(f),drifting(d),firstLoss(1),  
        secondLoss(1),porperty(p)  
        {}  
        void run( );  
        void doDrifting( );  
    private:  
        std::string name;  
        float friction;  
        float drifting;  
        float firstLoss;  
        float secondLoss;  
        float porperty;  
};  
  
void wheel::run()  
{  
    firstLoss=firstLoss*(1-porperty);  
    friction=friction*firstLoss;  
    std::cout<<" Tire wear"<<std::endl;  
}  
  
void wheel::doDrifting()  
{  
    secondLoss=secondLoss*(1-porperty);  
    drifting=drifting*secondLoss;  
    std::cout<<" car is drifting"<<std::endl;  
}  
  
class shell  
{  
    public:  
        shell(std::string c)  
        :color(c)  
        {}  
    private:  
        std::string color;  
};  
  
class brand  
{  
    public:  
        brand(std::string n,int p,float e)  
        :name(n),pamer(p),effect(e)  
        {}  
        int getPamer(){return pamer;}  
        float getEffect(){return effect;}  
    private:  
        std::string name;  
        int pamer;  
        float effect;  
};  
  
class engine  
{  
    public:  
        engine(std::string m,int s,int a)  
        :made(m),maxSpeed(s),acceleration(a)  
        {}  
        int accelerate(int speed,int t);  
    private:  
        std::string made;  
        int maxSpeed;  
        int acceleration;  
};  
int engine::accelerate(int speed,int t)  
{  
    if(speed<maxSpeed)  
    {  
        for(int i=1;i<=t;++i)  
        {  
            speed=speed+acceleration;  
            if(speed>maxSpeed)  
            {  
                speed=maxSpeed;  
                break;  
            }  
        }  
    }  
    std::cout<<" car is accelerating"<<std::endl;  
    return speed;  
}  
  
class car  
{  
    public:  
        car(std::string n,wheel *w,shell *s,brand *b,engine *e)  
        :name(n),_wheel(w),_shell(s),_brand(b),_engine(e),speed(0)  
        {}  
        void run( );  
        void drifting();  
        void accelerate(int t);  
        void collide(const car *c);  
        void showSpeed();  
        std::string getName();  
    private:  
        std::string name;  
        wheel * _wheel;  
        shell* _shell;  
        brand* _brand;  
        engine* _engine;  
        float speed;  
};  
std::string car::getName()  
{  
    return name;  
}  
void car::run()  
{  
    std::cout<<name;  
    _wheel->run( );  
}  
void car::drifting()  
{  
    std::cout<<name;  
    _wheel->doDrifting();  
}  
void car::accelerate(int t)  
{  
    std::cout<<name;  
    speed=_engine->accelerate(speed,t);  
}  
void car::collide(const car* c)  
{  
    if(_brand->getPamer()>=c->_brand->getPamer())  
    {  
        std::cout<<name<<" car is stronger"<<std::endl;  
    }  
    speed=speed*c->_brand->getEffect( );  
}  
  
void car::showSpeed()  
{  
    std::cout<<name<<" car's speed is "<<speed<<std::endl;  
}  
  
class carFactory  
{  
    public:  
        car* getcar(std::string carname,std::string wheelname,std::string  
 color,std::string brandname,std::string makename);  
        ~carFactory();  
    private:  
        std::map<std::string,wheel*> mw;  
        std::map<std::string,shell*> ms;  
        std::map<std::string,brand*> mb;  
        std::map<std::string,engine*> me;  
};  
  
car* carFactory::getcar(std::string carname,std::string wheelname,  
std::string color,std::string brandname,std::string makename)  
{  
    wheel *w;  
    std::map<std::string,wheel*>::iterator it1=mw.find(wheelname);  
    if(it1==mw.end())  
    {  
        float friction=getFriction(wheelname);  
        float drifting=getDrifting(wheelname);  
        float porperty=getPorperty(wheelname);  
        w=new wheel(wheelname,friction,drifting,porperty);  
        mw.insert(std::pair<std::string,wheel*>(wheelname,w));  
    }  
    else  
    {  
        w=it1->second;  
    }  
    shell *s;  
    std::map<std::string,shell*>::iterator it2=ms.find(color);  
    if(it2==ms.end())  
    {  
        s=new shell(color);  
        ms.insert(std::pair<std::string,shell*>(color,s));  
    }  
    else  
    {  
        s=it2->second;  
    }  
    brand *b;  
    std::map<std::string,brand*>::iterator it3=mb.find(brandname);  
    if(it3==mb.end())  
    {  
        float effect=getEffect(brandname);  
        float pamer=getPamer(brandname);  
        b=new brand(brandname,pamer,effect);  
        mb.insert(std::pair<std::string,brand*>(brandname,b));  
    }  
    else  
    {  
        b=it3->second;  
    }  
    engine *e;  
    std::map<std::string,engine*>::iterator it4=me.find(makename);  
    if(it4==me.end())  
    {  
        int maxSpeed=getMaxSpeed(makename);  
        int acceleration=getAcceleration(makename);  
        e=new engine(makename,maxSpeed,acceleration);  
        me.insert(std::pair<std::string,engine*>(makename,e));  
    }  
    else  
    {  
        e=it4->second;  
    }  
    return new car(carname,w,s,b,e);  
}  
carFactory::~carFactory()  
{  
    for(std::map<std::string,wheel*>::iterator it1=mw.begin();it1!=mw.end();)  
    {  
        delete it1->second;  
        mw.erase(it1++);  
    }  
    for(std::map<std::string,shell*>::iterator it2=ms.begin();it2!=ms.end();)  
    {  
        delete it2->second;  
        ms.erase(it2++);  
    }  
    for(std::map<std::string,brand*>::iterator it3=mb.begin();it3!=mb.end();)  
    {  
        delete it3->second;  
        mb.erase(it3++);  
    }  
    for(std::map<std::string,engine*>::iterator it4=me.begin();it4!=me.end();)  
    {  
        delete it4->second;  
        me.erase(it4++);  
    }  
}  
  
void collide(car* c1,car* c2)  
{  
    std::cout<<c1->getName()<<" and "<<c2->getName()<<" are collide "<<std::endl;  
    c1->collide(c2);  
    c2->collide(c1);  
}  
  
int main(int argc,char** argv)  
{  
    carFactory* c=new carFactory( );  
    car* c1=c->getcar("Han","Michelin","red","Ferrari","Ferrari");  
    car* c2=c->getcar("Bei","Bridgestone","white","BMW","BMW");  
    car* c3=c->getcar("Wu","Michelin","red","Benz","Ferrari");  
    c1->accelerate(40);  
    c2->accelerate(40);  
    c3->accelerate(40);  
    c1->run();  
    c2->run();  
    c3->run();  
    c1->drifting();  
    c2->drifting();  
    c3->drifting();  
    c1->showSpeed();  
    c2->showSpeed();  
    c3->showSpeed();  
    collide(c1,c3);  
    c1->showSpeed();  
    c2->showSpeed();  
    c3->showSpeed();  
        delete c;  
        delete c1;  
        delete c2;  
        delete c3;  
        return 0;  
}  
运行结果
如果有兴趣可以继续浏览该系列文章：
singleton pattern--单件模式
factory mothed pattern--工厂方法模式
abstract factory pattern--抽象工厂模式
builder pattern--建造者模式
prototype pattern--原型模式
adapter pattern--适配器模式
bridge pattern -- 桥接模式
composite pattern -- 组合模式
decorator pattern -- 装饰模式
flyweight pattern -- 享元模式