Chapter9—享元模式

LoveXming2025-09-30 13:49

享元模式

1 概念

享元模式使用对象池来尽可能地减少对对象池中已经存在的对象的二次创建。对象池的实现和使用是享元模式的核心，享元模式是利用对象池减少内存的使用量，避免重复创建大量对象的设计模式。

2 意图(Intent)

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

3 动机(Motivate)

采用纯粹对象方案的问题在于大量细粒度的对象会很快充斥在系统中，从而带来很高的运行时代价（主要指内存需求方面的代价）。 如何在避免大量细粒度对象问题的同时，让外部客户程序仍然能够透明地使用面向对象的方式来进行操作？

4 类图结构

5 角色定义

  • Flyweight（享元接口）：所有元件的高层规范，声明与外蕴状态互动的接口标准。
  • ConcreteFlyweight（享元实现）：享元接口的元件实现类，自身维护着内蕴状态，且能接受并响应外蕴状态，可以有多个实现，一个享元对象可以被作为一个"元"。
  • FlyweightFactory（享元工厂）：用来维护享元对象的工厂，负责对享元对象实例进行创建于管理，并对外提供获取享元对象的服务。

6 程序示例

共享网络设备

示例类图

抽象享元类INetworkDevice（网络设备类）

cpp 复制代码 
/**
 * @brief 抽象享元类INetworkDevice（网络设备类）
 */
class INetworkDevice
{
public:
    INetworkDevice() = default;
    virtual ~INetworkDevice() = default;

public:
    virtual string GetType() = 0;
    virtual void Use() = 0;
};

具体享元类Switch（交换机类）

cpp 复制代码 
/**
 * @brief 具体享元类Switch（交换机类）
 */
class Switch: public INetworkDevice
{
public:
    Switch(const string& strType);
    ~Switch() = default;

public:
    string GetType() override;
    void Use() override;

private:
    string m_strType;
};

Switch::Switch(const string &strType): m_strType(strType)
{
    // ...
}

string Switch::GetType()
{
    return m_strType;
}

void Switch::Use()
{
    qDebug() << "Linked by switch, type is" << m_strType;
}

具体享元类Hub（集线器类）

cpp 复制代码 
/**
 * @brief 具体享元类Hub（集线器类）
 */
class Hub: public INetworkDevice
{
public:
    Hub(const string& strType);
    ~Hub() = default;

public:
    string GetType() override;
    void Use() override;

private:
    string m_strType;
};

Hub::Hub(const string &strType): m_strType(strType)
{
    // ...
}

string Hub::GetType()
{
    return m_strType;
}

void Hub::Use()
{
    qDebug() << "Linked by Hub, type is" << m_strType;
}

享元工厂类DeviceFactory（网络设备工厂类）

cpp 复制代码 
/**
 * @brief 享元工厂类DeviceFactory（网络设备工厂类）
 */
class DeviceFactory
{
public:
    DeviceFactory();
    ~DeviceFactory();

public:
    INetworkDevice* GetNetworkDevice(const string& strType);
    int GetTotalDevice();
    int GetTotalTerminal();

private:
    vector<INetworkDevice*> m_vecDevice;
    int m_nTotalTerminal;
};

DeviceFactory::DeviceFactory(): m_nTotalTerminal(0)
{
    INetworkDevice* pSwitch = new Switch("Cisco - WS - C2950 - 24");
    INetworkDevice* pHub = new Hub("TP - LINK - HF8M");
    m_vecDevice.push_back(pSwitch);
    m_vecDevice.push_back(pHub);
}

DeviceFactory::~DeviceFactory()
{
    for (auto& pDevice:m_vecDevice)
    {
        if (nullptr != pDevice)
        {
            delete pDevice;
            pDevice = nullptr;
        }
    }
}

INetworkDevice *DeviceFactory::GetNetworkDevice(const string &strType)
{
    if (string::npos != strType.find("Cisco"))
    {
        ++m_nTotalTerminal;
        return m_vecDevice[0];
    }
    else if (string::npos != strType.find("TP"))
    {
        ++m_nTotalTerminal;
        return m_vecDevice[1];
    }
    else
    {
        return nullptr;
    }
}

int DeviceFactory::GetTotalDevice()
{
    return static_cast<int>(m_vecDevice.size());
}

int DeviceFactory::GetTotalTerminal()
{
    return m_nTotalTerminal;
}

测试函数

cpp 复制代码 
/**
 * @brief 测试函数
 */
void ClientTest()
{
    INetworkDevice* pSwitchA = nullptr;
    INetworkDevice* pSwitchB = nullptr;
    INetworkDevice* pSwitchC = nullptr;
    INetworkDevice* pHubA = nullptr;
    INetworkDevice* pHubB = nullptr;

    DeviceFactory* pDeviceFactory = new DeviceFactory();

    pSwitchA = pDeviceFactory->GetNetworkDevice("Cisco");
    pSwitchA->Use();

    pSwitchB = pDeviceFactory->GetNetworkDevice("Cisco");
    pSwitchB->Use();

    pSwitchC = pDeviceFactory->GetNetworkDevice("Cisco");
    pSwitchC->Use();

    pHubA = pDeviceFactory->GetNetworkDevice("TP");
    pHubA->Use();

    pHubB = pDeviceFactory->GetNetworkDevice("TP");
    pHubB->Use();

    qDebug() << "Total Device:" << pDeviceFactory->GetTotalDevice();
    qDebug() << "Total Terminal:" << pDeviceFactory->GetTotalTerminal();

    delete pDeviceFactory;
}

游戏背景图元

示例类图

绘图接口Drawable

cpp 复制代码 
/**
 * @brief 绘图接口Drawable
 */
class Drawable
{
public:
    Drawable() = default;
    virtual ~Drawable() = default;

public:
    virtual void Draw(int nX, int nY) = 0;
};

河流类 River

cpp 复制代码 
/**
 * @brief 河流类 River
 */
class River: public Drawable
{
public:
    River();
    ~River();

public:
    void Draw(int nX, int nY) override;

private:
    string m_strImage;
};

River::River()
{
    m_strImage = "河流";
}

River::~River()
{

}

void River::Draw(int nX, int nY)
{
    qDebug() << "在位置[ " << nX << ":" << nY << "]上绘制图片[" << m_strImage.c_str() << "]";
}

草地类 Grass

cpp 复制代码 
/**
 * @brief 草地类 Grass
 */
class Grass: public Drawable
{
public:
    Grass();
    ~Grass();

public:
    void Draw(int nX, int nY) override;

private:
    string m_strImage;
};

Grass::Grass()
{
    m_strImage = "草地";
}

Grass::~Grass()
{

}

void Grass::Draw(int nX, int nY)
{
    qDebug() << "在位置[ " << nX << ":" << nY << "]上绘制图片[" << m_strImage.c_str() << "]";
}

道路类 Road

cpp 复制代码 
/**
 * @brief 道路类 Road
 */
class Road: public Drawable
{
public:
    Road();
    ~Road();

public:
    void Draw(int nX, int nY) override;

private:
    string m_strImage;
};

Road::Road()
{
    m_strImage = "道路";
}

Road::~Road()
{

}

void Road::Draw(int nX, int nY)
{
    qDebug() << "在位置[ " << nX << ":" << nY << "]上绘制图片[" << m_strImage.c_str() << "]";
}

房屋类 House

cpp 复制代码 
/**
 * @brief 房屋类 House
 */
class House: public Drawable
{
public:
    House();
    ~House();

public:
    void Draw(int nX, int nY) override;

private:
    string m_strImage;
};

House::House()
{
    m_strImage = "房屋";
}

House::~House()
{

}

void House::Draw(int nX, int nY)
{
    qDebug() << "在位置[ " << nX << ":" << nY << "]上绘制图片[" << m_strImage.c_str() << "]";
}

图件工厂类 TileFactory

cpp 复制代码 
/**
 * @brief 图件工厂类 TileFactory
 */
class TileFactory
{
public:
    TileFactory() = default;
    ~TileFactory() = default;

public:
    std::shared_ptr<Drawable> GetDrawable(const string& strImage);


private:
    std::map<string, std::shared_ptr<Drawable>> m_mapImage;
};

std::shared_ptr<Drawable> TileFactory::GetDrawable(const string &strImage)
{
    if (m_mapImage.end() != m_mapImage.find(strImage))
        return m_mapImage[strImage];

    if ("河流" == strImage)
    {
        m_mapImage.insert({strImage, std::make_shared<River>()});
    }
    else if ("草地" == strImage)
    {
        m_mapImage.insert({strImage, std::make_shared<Grass>()});
    }
    else if ("道路" == strImage)
    {
        m_mapImage.insert({strImage, std::make_shared<Road>()});
    }
    else if ("房屋" == strImage)
    {
        m_mapImage.insert({strImage, std::make_shared<House>()});
    }

    return m_mapImage[strImage];
}

测试函数

cpp 复制代码 
/**
 * @brief 测试函数
 */
void ClientTest()
{
    TileFactory factory;
    factory.GetDrawable("河流")->Draw(10, 10);
    factory.GetDrawable("道路")->Draw(10, 10);
    factory.GetDrawable("草地")->Draw(10, 10);
    factory.GetDrawable("房屋")->Draw(10, 10);
}

7 思考小结

享元模式优点

  • 极大减少内存中对象数量，使得相同对象或相似对象在内存中只保存一份
  • 享元模式的外部状态相对独立，而且不会影响其内部状态，从而使得享元对象可以在不同的环境中被共享

享元模式缺点

  • 享元模式让系统更复杂，特别是需要分离内部状态和外部状态，这使得程序的逻辑复杂化
  • 为了使对象可以共享，享元模式需要将享元对象的状态外部化，而读取外部状态使得运行时间变长

当一个系统有大量的对象，这些对象耗费大量的内存，对象的状态中的大部分都可以外部化，对象可以按照内蕴状态分成很多的组，当把外蕴对象从对象中剔除时，每一个组都可以仅用一个对象代替，满足以上的这些条件的系统可以使用享元对象。最后，使用享元模式需要维护一个记录了系统已有的所有享元的表，而这需要耗费资源。因此，应当在有足够多的享元实例可供共享时才值得使用享元模式。

相关推荐
float_com2 分钟前
【java阶段练习】----- 学生管理系统
java
爱笑的源码基地4 分钟前
基于Java+Spring Boot、Vue的B/S医院患者随访管理系统源码，支持二次开发，三级随访体系（出院/门诊随访）、智慧云库（表单配置）
java·vue.js·spring boot·源码·程序代码·随访系统·诊后回访
西幻凌云10 分钟前
认识设计模式——单例模式
c++·单例模式·设计模式·线程安全·饿汉和懒汉
我曾遇到一束光13 分钟前
Springboot3.X+security6.5+jdk21
java·开发语言
jtymyxmz17 分钟前
1.1.4 Spring的下载及目录结构
java·后端·spring
Tipriest_17 分钟前
C++ 图形中间件库Magnum详细介绍
开发语言·c++·magnum
robch19 分钟前
Spring 的 DelegatingFilterProxy 用法
java·后端·spring
tryxr25 分钟前
Java 不同创建线程的方式什么时候才可以使用 this 来获取线程的引用
java·开发语言·多线程
代码程序猿RIP29 分钟前
【C 语言面试】高频考点深度解析
java·面试·职场和发展
ue星空41 分钟前
UEC++ 创建默认子对象CreateDefaultSubobject
c++
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03综合整理：pdf预览显示：你尝试预览的文件可能对你的计算机有害。如果你信任此文件以及其来源，请打开此文件以看其内容，如何解决以正常预览文件04安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）05Linux下V2Ray安装配置指南06BongoCat - 跨平台键盘猫动画工具07Labelme从安装到标注：零基础完整指南08智能库存管理的需求预测模型：从业务痛点到落地代码的完整实践09看了下昨日泄露的苹果 App Store 源码……10GitLab 零基础入门指南：从安装到项目管理全流程