1.意图

享元模式（Flyweight Pattern）主要用于减少创建对象的数量，以减少内存占用和提高性能。它属于结构型模式，提供了减少对象数量，从而改善应用所需的对象结构的方式。

“共享” 是享元模式的精髓，将那些数量众多的，具有很多内部状态而很少的外部状态的对象进行共享，就是享元模式的使用方式。

如本篇中的例子所示：在一个大型游戏中，每一局的内部，存在大量的细粒度的实例对象：

--各个角色的数量众多，成百上千。

--每个角色都有大量的内部状态，如战斗力值，武器，位置，队伍等等，很多属性。这些内部属性，不会随着客户端多少而改变。也就是不管玩家有多少，角色属性是唯一的。

--每个角色的外部状态很少。上面所说的属性值，基本都是内部状态，存储在服务端。与客户端相关的属性，相对很少。

2.UML类图

享元模式共分为四种角色：

Flyweight（抽象享元类）：通常是一个接口或者是抽象类，在抽象享元类中声明了共享享元类的公共方法，通过这些方法可以访问享元类的内部数据（内部状态），也可以设置享元类的外部数据（外部状态）

Concrete Flyweight（共享具体享元类）：实现抽象享元类，其实例称为享元对象，一般为单例模式，提供唯一的享元对象

UnsharedConcrete Flyweight（非共享具体享元类）：实现抽象享元类，但是不共享，通过构造函数进行实例化

Flyweight Factory（享元工厂类）：创建并管理享元对象，以内部的键值对结构存储享元对象

3.代码实现

如第1节所说，我们使用一个游戏相关的代码场景，来说明享元模式。

在一个游戏中，会有大量的角色对象，且这些对象的创建成本比较高。如果每次都需要服务端动态创建大量的这种类似的重复的对象，服务端压力巨大。这时候，就是享元模式减少内存并提高性能的绝佳机会。

#include 
   
    #include 
    #include 
     
      enum WeaponType {    Minigun = 1,  //机枪    Pistol  = 2,  //手枪    Knife   = 3,  //刺刀};enum RoleType {    EagleAlpha  = 1,    EagleBeta   = 2,    WolfAlpha   = 3,    WolfBeta    = 4,};class Role {public:    virtual void SetWeapon(WeaponType wt) = 0;    virtual std::string Desription() = 0;};//鹰队class EagleTeam : public Role {public:    EagleTeam(int power) : power(power) {}    void SetWeapon(WeaponType wt) {        weapon = wt;    }    std::string Desription() {        char buffer[20];        sprintf_s(buffer, sizeof(buffer), "%p", this);        return "Eagle with power:" + std::to_string(power) + ", weapon:" + std::to_string(weapon) + ", objPtr:" + buffer;    }private:    int power;  //战斗力值    WeaponType weapon;  //武器类型};//狼队class WolfTeam : public Role {public:    WolfTeam(int power) : power(power) {}    void SetWeapon(WeaponType wt) {        weapon = wt;    }    std::string Desription() {        char buffer[20];        sprintf_s(buffer, sizeof(buffer), "%p", this);        return "Wolf with power:" + std::to_string(power) + ", weapon:" + std::to_string(weapon) + ", objPtr:" + buffer;    }private:    int power;  //战斗力值    WeaponType weapon;  //武器类型};class RoleFactory {public:    Role* GetRole(RoleType roleType) {        auto iter = roles.find(roleType);        if (iter != roles.end()) {            return iter->second;        }        Role* r = NULL;        switch (roleType) {        case WolfAlpha:        {            r = new WolfTeam(100);            r->SetWeapon(Minigun);            roles[roleType] = r;            break;        }        case WolfBeta:        {            r = new WolfTeam(60);            r->SetWeapon(Pistol);            roles[roleType] = r;            break;        }        case EagleAlpha:        {            r = new EagleTeam(80);            r->SetWeapon(Pistol);            roles[roleType] = r;            break;        }        case EagleBeta:        {            r = new EagleTeam(40);            r->SetWeapon(Knife);            roles[roleType] = r;            break;        }        default:            break;        }        return r;    }private:    std::map
      
        roles;};int main() {    RoleFactory rf;    Role *role = rf.GetRole(EagleAlpha);    std::cout << role->Desription() << std::endl;    role = rf.GetRole(EagleBeta);    std::cout << role->Desription() << std::endl;    role = rf.GetRole(EagleAlpha);    std::cout << role->Desription() << std::endl;    role = rf.GetRole(WolfBeta);    std::cout << role->Desription() << std::endl;    role = rf.GetRole(WolfAlpha);    std::cout << role->Desription() << std::endl;    role = rf.GetRole(WolfBeta);    std::cout << role->Desription() << std::endl;    return 0;}

运行结果：

Eagle with power:80, weapon:2, objPtr:005ED3D8

Eagle with power:40, weapon:3, objPtr:005ED448

Eagle with power:80, weapon:2, objPtr:005ED3D8

Wolf with power:60, weapon:2, objPtr:005ED410

Wolf with power:100, weapon:1, objPtr:005ED4B8

Wolf with power:60, weapon:2, objPtr:005ED410

可以看到，相同类型的对象，是共享的（this指针地址相同）。

4.总结

享元模式的核心思想就是尽可能的共享对象，特别适用于存在大量细粒度对象，而这些对象内部状态特别多，外部状态较少的场景。

共享具体享元类与非共享具体享元类实现抽象享元类，能够保证他们对外具有一致的行为接口，为客户端的使用提供了便利，客户端通过享元工厂类获取共享享元对象。

转载地址：http://pleji.baihongyu.com/

你可能感兴趣的文章