简单LRU算法实现的Cache（C++）

最新推荐文章于 2025-07-18 11:27:31 发布
转载 最新推荐文章于 2025-07-18 11:27:31 发布 · 1k 阅读 · 0

本文提供了一个使用C++实现的简单LRU算法的缓存，包括基本的缓存操作如添加、获取和删除。该实现不支持多线程，并且未进行加锁处理。

简单LRU算法实现的Cache（C++）

此实现不适合多线程！~没有加锁！~
  1. #pragma once   
  2. #include <map>   
  3. #include <time.h>   
  4. template<typename CacheKey, typename CacheValue>  
  5. class LRUCache  
  6. {  
  7. public:  
  8.     LRUCache(void);  
  9.     LRUCache(int capacity);  
  10.     ~LRUCache(void);  
  11.     void Put(const CacheKey & key, const CacheValue & value);  
  12.     bool Get(const CacheKey & key, CacheValue & value);  
  13.     void Remove(const CacheKey & key);  
  14.     unsigned int Size();  
  15. private:  
  16.     void removeRencentlyLeastAccess();  
  17. private:  
  18.     typedef struct tagValueEntry {  
  19.         CacheValue Value;  
  20.         int Count;  
  21.         long LastAccess;  
  22.     } ValueEntry;  
  23.     typedef typename std::map<CacheKey, ValueEntry> Cache;  
  24.     typedef typename Cache::iterator CacheItr;  
  25.     Cache m_Cache;  
  26.     unsigned int m_CacheSize;  
  27.     const static int DefautCacheSize = 100;  
  28.     const static long MiniAccess = 20;  
  29. };  
  30. template<typename CacheKey, typename CacheValue>  
  31. LRUCache<CacheKey, CacheValue>::LRUCache(void) :   
  32. m_CacheSize(DefautCacheSize)  
  33. {  
  34. }  
  35. template<typename CacheKey, typename CacheValue>  
  36. LRUCache<CacheKey, CacheValue>::LRUCache(int capacity) :   
  37. m_CacheSize(capacity)  
  38. {  
  39. }  
  40. template<typename CacheKey, typename CacheValue>  
  41. LRUCache<CacheKey, CacheValue>::~LRUCache(void)  
  42. {  
  43. }  
  44. template<typename CacheKey, typename CacheValue>  
  45. void LRUCache<CacheKey, CacheValue>::Put(const CacheKey & key, const CacheValue & value)  
  46. {  
  47.     if(m_Cache.size() >= m_CacheSize)  
  48.     {  
  49.         removeRencentlyLeastAccess();  
  50.     }  
  51.     ValueEntry entry;  
  52.     entry.Value = value;  
  53.     entry.Count = 1;  
  54.     entry.LastAccess = clock();  
  55.     m_Cache.insert(std::make_pair(key, entry));  
  56. }  
  57. template<typename CacheKey, typename CacheValue>  
  58. bool LRUCache<CacheKey, CacheValue>::Get(const CacheKey & key, CacheValue & value)  
  59. {  
  60.     CacheItr itr = m_Cache.find(key);  
  61.     if(itr != m_Cache.end())  
  62.     {  
  63.         value = itr->second.Value;  
  64.         return true;  
  65.     }  
  66.     return false;  
  67. }  
  68. template<typename CacheKey, typename CacheValue>  
  69. void LRUCache<CacheKey, CacheValue>::Remove(const CacheKey & key)  
  70. {  
  71.     CacheItr itr = m_Cache.find(key);  
  72.     if(itr != m_Cache.end())  
  73.     {  
  74.         m_Cache.erase(key);  
  75.     }  
  76. }  
  77. template<typename CacheKey, typename CacheValue>  
  78. unsigned int LRUCache<CacheKey, CacheValue>::Size()  
  79. {  
  80.     return m_Cache.size();  
  81. }  
  82. template<typename CacheKey, typename CacheValue>  
  83. void LRUCache<CacheKey, CacheValue>::removeRencentlyLeastAccess()  
  84. {  
  85.     long earliest = 0;  
  86.     const CacheKey * ToBeRemovedByTime;  
  87.     int least = 0;  
  88.     const CacheKey * ToBeRemovedByCount;  
  89.     CacheItr itr = m_Cache.begin();  
  90.     if(itr != m_Cache.end())  
  91.     {  
  92.         earliest = itr->second.LastAccess;  
  93.         ToBeRemovedByTime = &(itr->first);  
  94.         least = itr->second.Count;  
  95.         ToBeRemovedByCount = &(itr->first);  
  96.           
  97.         for(;itr != m_Cache.end();++itr)  
  98.         {  
  99.             if(earliest > itr->second.LastAccess)  
  100.             {  
  101.                 ToBeRemovedByTime = &(itr->first);  
  102.             }  
  103.             if(least > itr->second.Count)  
  104.             {  
  105.                 ToBeRemovedByCount = &(itr->first);  
  106.             }  
  107.         }  
  108.         if (least > MiniAccess) {  
  109.             m_Cache.erase(*ToBeRemovedByTime);  
  110.         } else {  
  111.             m_Cache.erase(*ToBeRemovedByCount);  
  112.         }  
  113.     }  
  114. }  
[cpp] view plain copy
  1. #pragma once  
  2. #include <map>  
  3. #include <time.h>  
  4. template<typename CacheKey, typename CacheValue>  
  5. class LRUCache  
  6. {  
  7. public:  
  8.     LRUCache(void);  
  9.     LRUCache(int capacity);  
  10.     ~LRUCache(void);  
  11.     void Put(const CacheKey & key, const CacheValue & value);  
  12.     bool Get(const CacheKey & key, CacheValue & value);  
  13.     void Remove(const CacheKey & key);  
  14.     unsigned int Size();  
  15. private:  
  16.     void removeRencentlyLeastAccess();  
  17. private:  
  18.     typedef struct tagValueEntry {  
  19.         CacheValue Value;  
  20.         int Count;  
  21.         long LastAccess;  
  22.     } ValueEntry;  
  23.     typedef typename std::map<CacheKey, ValueEntry> Cache;  
  24.     typedef typename Cache::iterator CacheItr;  
  25.     Cache m_Cache;  
  26.     unsigned int m_CacheSize;  
  27.     const static int DefautCacheSize = 100;  
  28.     const static long MiniAccess = 20;  
  29. };  
  30. template<typename CacheKey, typename CacheValue>  
  31. LRUCache<CacheKey, CacheValue>::LRUCache(void) :   
  32. m_CacheSize(DefautCacheSize)  
  33. {  
  34. }  
  35. template<typename CacheKey, typename CacheValue>  
  36. LRUCache<CacheKey, CacheValue>::LRUCache(int capacity) :   
  37. m_CacheSize(capacity)  
  38. {  
  39. }  
  40. template<typename CacheKey, typename CacheValue>  
  41. LRUCache<CacheKey, CacheValue>::~LRUCache(void)  
  42. {  
  43. }  
  44. template<typename CacheKey, typename CacheValue>  
  45. void LRUCache<CacheKey, CacheValue>::Put(const CacheKey & key, const CacheValue & value)  
  46. {  
  47.     if(m_Cache.size() >= m_CacheSize)  
  48.     {  
  49.         removeRencentlyLeastAccess();  
  50.     }  
  51.     ValueEntry entry;  
  52.     entry.Value = value;  
  53.     entry.Count = 1;  
  54.     entry.LastAccess = clock();  
  55.     m_Cache.insert(std::make_pair(key, entry));  
  56. }  
  57. template<typename CacheKey, typename CacheValue>  
  58. bool LRUCache<CacheKey, CacheValue>::Get(const CacheKey & key, CacheValue & value)  
  59. {  
  60.     CacheItr itr = m_Cache.find(key);  
  61.     if(itr != m_Cache.end())  
  62.     {  
  63.         value = itr->second.Value;  
  64.         return true;  
  65.     }  
  66.     return false;  
  67. }  
  68. template<typename CacheKey, typename CacheValue>  
  69. void LRUCache<CacheKey, CacheValue>::Remove(const CacheKey & key)  
  70. {  
  71.     CacheItr itr = m_Cache.find(key);  
  72.     if(itr != m_Cache.end())  
  73.     {  
  74.         m_Cache.erase(key);  
  75.     }  
  76. }  
  77. template<typename CacheKey, typename CacheValue>  
  78. unsigned int LRUCache<CacheKey, CacheValue>::Size()  
  79. {  
  80.     return m_Cache.size();  
  81. }  
  82. template<typename CacheKey, typename CacheValue>  
  83. void LRUCache<CacheKey, CacheValue>::removeRencentlyLeastAccess()  
  84. {  
  85.     long earliest = 0;  
  86.     const CacheKey * ToBeRemovedByTime;  
  87.     int least = 0;  
  88.     const CacheKey * ToBeRemovedByCount;  
  89.     CacheItr itr = m_Cache.begin();  
  90.     if(itr != m_Cache.end())  
  91.     {  
  92.         earliest = itr->second.LastAccess;  
  93.         ToBeRemovedByTime = &(itr->first);  
  94.         least = itr->second.Count;  
  95.         ToBeRemovedByCount = &(itr->first);  
  96.           
  97.         for(;itr != m_Cache.end();++itr)  
  98.         {  
  99.             if(earliest > itr->second.LastAccess)  
  100.             {  
  101.                 ToBeRemovedByTime = &(itr->first);  
  102.             }  
  103.             if(least > itr->second.Count)  
  104.             {  
  105.                 ToBeRemovedByCount = &(itr->first);  
  106.             }  
  107.         }  
  108.         if (least > MiniAccess) {  
  109.             m_Cache.erase(*ToBeRemovedByTime);  
  110.         } else {  
  111.             m_Cache.erase(*ToBeRemovedByCount);  
  112.         }  
  113.     }  
  114. }  


LRU Cache的简单c++实现
笑笑的程序人生
09-05 1万+
什么是 LRU LRU Cache是一个Cache的置换算法，含义是“最近最少使用”，把满足“最近最少使用”的数据从Cache中剔除出去，并且保证Cache中第一个数据是最近刚刚访问的，因为这样的数据更有可能被接下来的程序所访问。 LRU的应用比较广泛，最基础的内存页置换中就用了，对了，这里有个概念要清楚一下，Cache不见得是CPU的高速缓存的那个Cache，这里的Cache直接翻译为缓
【算法】LRU缓存算法的C++实现
Conner7的博客
03-09 6448
LRU缓存算法是一种淘汰算法，也是一道经典的面试题，本文对LRU缓存算法的C++实现做了讲解。
LRU算法 C++实现
06-30
操作系统中的一个算法 C++实现的，Lru算法
【LRU的C＋＋实现】
最新发布
qq_51339039的博客
07-18 476
LRU(Least Recently Used): 最近最少使用，一种缓存替换策略/内存管理的算法。
LRU Cache的简单C++实现
01-20
什么是 LRU 　　LRU Cache是一个Cache的置换算法，含义是“近少使用”，把满足“近少使用”的数据从Cache中剔除出去，并且保证Cache中第一个数据是近刚刚访问的，因为这样的数据更有可能被接下来的程序所访问。 　　LRU的应用比较广泛，基础的内存页置换中用了，对了，这里有个概念要清楚一下，Cache不见得是CPU的高速缓存的那个Cache，这里的Cache直接翻译为缓存，是两种存储方式的速度有比较大的差别，都可以用Cache缓存数据，比如硬盘明显比内存慢，所以常用的数据我们可以Cache在内存中。 　　LRU 基本算法描述 　　前提： 　　由于我只是简单实现一下这个算
LRU Cache
wusecaiyun的专栏
08-20 515
LRU是Least Recently Used的缩写，意思是最近最少使用，它是一种Cache替换算法。 什么是Cache？狭义的Cache指的是位于CPU和主存间的快速RAM， 通常它不像系统主存那样使用DRAM技术，而使用昂贵但较快速的SRAM技术。 广义上的Cache指的是位于速度相差较大的两种硬件之间， 用于协调两者数据传输速度差异的结构。除了CPU与主存之间有Cache， 内存与硬盘之间也
C++ LRU算法
一个大佬的博客
06-13 727
【代码】C++ LRU算法。
LRU算法（C++实现）
热门推荐
邹亮的博客
03-29 1万+
一、LRU算法简介 对于web开发而言，缓存必不可少，也是提高性能最常用的方式。无论是浏览器缓存，还是服务端的缓存(通过memcached或者redis等内存数据库)。缓存不仅可以加速用户的访问，同时也可以降低服务器的负载和压力。那么，了解常见的缓存淘汰算法的策略和原理就显得特别重要。 常见的缓存算法 LRU (Least recently used) 最近最少使用，如果数据最近被访问过，那...
[算法与数据结构]：LRU Cache 的原理与C++实现
Bin_Dut的博客
01-18 872
LRU Cache的原理与算法实现
C++实现LRU Cache
qq_33457548的博客
08-02 534
1、算法思路： put操作思路： 用一个双向链表和一个哈希表； 每添加一个(key, value),先判断是否在哈希表中存在，如果存在，那么删除哈希表中的键值对和双向链表中的该元素； 再往双向链表头部增加添加的(key, value)和哈希表中增加(key,value); 最后判断是否超过capacity,若超过则弹出链表尾部元素和删除哈希表中该键值对。 优化： 哈希表中保存&lt...
C++实现LRU cache
线上幽灵
10-25 478
C++实现LRU cache
C++实现一个LRU Cache
iTer的专栏
11-29 1007
#include #include #include using namespace std; using namespace stdext; template struct LRUCacheEntry { K key; T data; LRUCacheEntry* prev; LRUCacheEntry* next; }; template class LRUCache {
LRU cache implementation in C++
asu - 速度与激情
11-11 1383
©2010-2012 Tim Day  timday@timday.com  www.timday.com Abstract A key-value container providing caching with a least-recently-used replacement strategy is a useful tool in any
一种简单的LRU cache设计 C++
一缕阳光的博客
01-25 628
最近在工作中需要用到LRU cache用作缓存来提高性能，经过查阅各种资料，了解了其运行的机制，如下： LRU cache可以用于在内存中保持当前的热点数据，下面实现一个有大小限制的lru cache，相关如下：     1. 模板化；     2. 利用std::unordered_map实现o(1)查找，利用std::list实现o(1)删除 (双链表+hash表）；     3. 用...
用C++实现一个LRU cache
简洁是智慧的灵魂,冗长是浮浅的辞藻
11-14 523
#include #define DEFAULT_LRU_CAPACITY 10000 template class LRUCache { struct Node { K key; V value; Node *prev, *next; Node(const K& key, const V& value) : key(key) , value(value)
LRU算法（c++）
冰糖雪梨的学习笔记
06-11 270
least recently used（最近最少使用算法）
LRU Cache的C++实现
chencong125的博客
07-05 405
方法一：双链表+哈希表map #include<iostream> #include<map> using namespace std;struct Node { int key; int value; Node* pre; Node* next; Node(int key=-1,int value=-1):key(key),value(value),pre(
lru算法队列实现c++
12-31
### 使用C++实现LRU缓存淘汰算法 #### 定义与概述 LRU（Least Recently Used），即最近最久未使用，是一种常用的页面置换算法，在计算机操作系统中用于管理内存中的页表项。当物理内存不足时，优先移除那些长时间...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值