常见设计模式解析和实现(C++)FlyWeight模式

简介: 作用:运用共享技术有效地支持大量细粒度的对象   UML结构图:   解析: Flyweight模式在大量使用一些可以被共享的对象的时候使用。

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

 

UML结构图:


 

解析:

Flyweight模式在大量使用一些可以被共享的对象的时候使用。比如,在QQ聊天时很多时候你懒得回复又不得不回复,一般会用一些客套的话语敷衍别人,如“呵呵”,“好的”等待之类的,这些简单的答复其实每个人都是提前定义好的,在使用的时候才调用起来。

Flyweight就是基于解决这种问题的思路而产生的,当需要一个可以在其他地方共享使用的对象的时候,先去查询是否已经存在了同样的对象,如果没有就生成之;有的话就直接使用

因此,Flyweight模式和Factory模式也经常混用。

 

实现:

需要说明的是下面的实现仅仅实现了对可共享对象的使用,非可共享对象的使用没有列出,因为这个不是Flyweight模式的重点。

这里的实现要点就是采用一个list链表来保存这些可以被共享的对象,需要使用的时候就到链表中查询是不是已经存在了,如果不存在就初始化一个,然后返回这个对象的指针。

 (1)Flywight.h

[cpp]  view plain copy
  1. #include <string>  
  2. #include <list>  
  3.   
  4. typdef std::string STATE;  
  5.   
  6.   
  7. class Flyweight  
  8. {  
  9. public:  
  10.     virtual ~Flyweight(){}  
  11.   
  12.     STATE GetInstrinsicState();  
  13.     virtual void Operation(STATE &ExtrinsicState) = 0;  
  14.   
  15. protected:  
  16.     Flyweight(const STATE& state):m_State(state)  
  17.     {  
  18.     }  
  19. private:  
  20.     STATE m_State;  
  21. };  
  22.   
  23.   
  24. class FlyweightFactory  
  25. {  
  26. public:  
  27.     FlyweightFactory(){}  
  28.     ~FlyweightFactory();  
  29.   
  30.     Flyweight* GetFlyweight(const STATE& key);  
  31.   
  32. private:  
  33.     std::list<Flyweight*> m_listFlyweight;  
  34. };  
  35.   
  36.   
  37. class ConcreateFlyweight : public Flyweight  
  38. {  
  39. public:  
  40.     ConcreateFlyweight(const STATE& state) : Flyweight(state)  
  41.     {  
  42.     }  
  43.   
  44.     virtual ~ConcreateFlyweight(){}  
  45.   
  46.     virtual void Operation(STATE &ExtrinsicState);  
  47. };  

(2)Flyweight.cpp


[cpp]  view plain copy
  1. #include "Flyweight.h"  
  2. #include <iostream>  
  3.   
  4.   
  5. inline STATE Flyweight::GetInstrinsicState()  
  6. {  
  7.     return m_State;  
  8. }  
  9.   
  10.   
  11.   
  12. FlyweightFactory::~FlyweightFactory()  
  13. {  
  14.     std::list<Flyweight*>::iterator iter1, iter2, temp;  
  15.   
  16.     for (iter1 = m_listFlyweight.begin();  
  17.          iter2 = m_listFlyweight.end();   
  18.          iter1 != iter2; )  
  19.     {  
  20.         temp = iter1;  
  21.         ++iter1;  
  22.         delete (*temp);  
  23.     }  
  24.   
  25.     m_listFlyweight.clear();  
  26. }  
  27.   
  28.   
  29. Flyweight* FlyweightFactory::GetFlyweight(const STATE &key)  
  30. {  
  31.     std::list<Flyweight*>::iterator iter1, iter2;  
  32.   
  33.     for (iter1 = m_listFlyweight.begin(), iter2 = m_listFlyweight.end();   
  34.         iter1 != iter2;  
  35.         ++iter1)  
  36.     {  
  37.         if ((*iter1)->GetInstrinsicState() == key)  
  38.         {  
  39.             std::cout << "The Flyweight:" << key << "already exists" << std::endl;  
  40.             return (*iter1);  
  41.         }  
  42.     }  
  43.   
  44.     std::cout << "Creating a new Flyweight:" << key << std::endl;  
  45.     Flyweight* flyweight = new ConcreateFlyweight(key);  
  46.     m_listFlyweight.push_back(flyweight);  
  47. }  
  48.   
  49. void ConcreateFlyweight::Operation(STATE & ExtrinsicState)  
  50. {  
  51. }  



(3)main.cpp

[cpp]  view plain copy
  1. #include "FlyWeight.h"  
  2.   
  3. int main()  
  4. {  
  5.     FlyweightFactory flyweightfactory;  
  6.     flyweightfactory.GetFlyweight("Hell");  
  7.     flyweightfactory.GetFlyweight("world");  
  8.     flyweightfactory.GetFlyweight("Hell");  
  9.   
  10.     return 0;  
  11. }  
目录
相关文章
|
8月前
|
设计模式 Java 数据库连接
【设计模式】【创建型模式】工厂方法模式(Factory Methods)
一、入门 什么是工厂方法模式? 工厂方法模式(Factory Method Pattern)是一种创建型设计模式,它定义了一个用于创建对象的接口,但由子类决定实例化哪个类。工厂方法模式使类的实例化延迟
255 16
|
8月前
|
设计模式 存储 缓存
【设计模式】【结构型模式】享元模式(Flyweight)
一、入门 什么是享元模式? 享元模式(Flyweight Pattern)是一种结构型设计模式,旨在通过共享对象来减少内存使用,特别适用于存在大量相似对象的情况。 它的核心思想是将对象的内在状态(不变
298 16
|
8月前
|
设计模式 负载均衡 监控
并发设计模式实战系列(2):领导者/追随者模式
🌟 ​大家好,我是摘星!​ 🌟今天为大家带来的是并发设计模式实战系列,第二章领导者/追随者(Leader/Followers)模式,废话不多说直接开始~
247 0
|
8月前
|
设计模式 监控 Java
并发设计模式实战系列(1):半同步/半异步模式
🌟 ​大家好,我是摘星!​ 🌟今天为大家带来的是并发设计模式实战系列,第一章半同步/半异步(Half-Sync/Half-Async)模式,废话不多说直接开始~
239 0
|
8月前
|
设计模式 安全 Java
并发设计模式实战系列(12):不变模式(Immutable Object)
🌟 大家好,我是摘星!🌟今天为大家带来的是并发设计模式实战系列,第十二章,废话不多说直接开始~
204 0
|
11月前
|
编译器 C++ 开发者
【C++篇】深度解析类与对象(下)
在上一篇博客中,我们学习了C++的基础类与对象概念,包括类的定义、对象的使用和构造函数的作用。在这一篇,我们将深入探讨C++类的一些重要特性,如构造函数的高级用法、类型转换、static成员、友元、内部类、匿名对象,以及对象拷贝优化等。这些内容可以帮助你更好地理解和应用面向对象编程的核心理念,提升代码的健壮性、灵活性和可维护性。
|
8月前
|
设计模式 算法 Java
设计模式觉醒系列(04)策略模式|简单工厂模式的升级版
本文介绍了简单工厂模式与策略模式的概念及其融合实践。简单工厂模式用于对象创建,通过隐藏实现细节简化代码;策略模式关注行为封装与切换,支持动态替换算法,增强灵活性。两者结合形成“策略工厂”,既简化对象创建又保持低耦合。文章通过支付案例演示了模式的应用,并强调实际开发中应根据需求选择合适的设计模式,避免生搬硬套。最后推荐了JVM调优、并发编程等技术专题,助力开发者提升技能。
|
8月前
|
设计模式 Prometheus 监控
并发设计模式实战系列(20):扇出/扇入模式(Fan-Out/Fan-In)(完结篇)
🌟 大家好,我是摘星!🌟今天为大家带来的是并发设计模式实战系列,第二十章,废话不多说直接开始~
295 0
|
9月前
|
存储 监控 算法
基于 C++ 哈希表算法的局域网如何监控电脑技术解析
当代数字化办公与生活环境中,局域网的广泛应用极大地提升了信息交互的效率与便捷性。然而,出于网络安全管理、资源合理分配以及合规性要求等多方面的考量,对局域网内计算机进行有效监控成为一项至关重要的任务。实现局域网内计算机监控,涉及多种数据结构与算法的运用。本文聚焦于 C++ 编程语言中的哈希表算法,深入探讨其在局域网计算机监控场景中的应用,并通过详尽的代码示例进行阐释。
196 4
|
11月前
|
数据可视化 算法 数据挖掘
用傅里叶变换解码时间序列:从频域视角解析季节性模式
本文介绍了如何使用傅里叶变换和周期图分析来识别时间序列中的季节性模式,特别是在能源消耗数据中。通过Python实现傅里叶变换和周期图,可以有效提取并量化时间序列中的主要和次要频率成分,克服传统可视化分析的局限性。这对于准确捕捉时间序列中的季节性变化具有重要意义。文章以AEP能源消耗数据为例,展示了如何应用这些方法识别日、周、半年等周期模式。
518 3
用傅里叶变换解码时间序列:从频域视角解析季节性模式

推荐镜像

更多
  • DNS