LRU 缓存的实现

最新推荐文章于 2024-07-18 14:40:29 发布

原创最新推荐文章于 2024-07-18 14:40:29 发布 · 465 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#缓存

c++/poco 专栏收录该内容

4 篇文章

订阅专栏

本文详细介绍了LRU（最近最少使用）缓存淘汰策略的C++实现，包括缓存大小限制、对象更新及查询效率优化。通过使用双向链表和哈希映射，确保了在O(1)时间内完成查找和插入操作。当缓存满时，会自动移除最久未使用的对象，以保持高效性能。

LRU缓存的实现有以下几个着重点：

1.缓存大小

2.被用的对象排到头

3.查询效率的问题。

最久未使用的对象被移除，即是在Put新对象时，size > capacity时，需要删除list尾部的数据，同时删除cache_中，并且把Put的对象放在list的头部

为了提高查询效率用map存放一个key值，只有当find的时候，效率高一点。

下面是简单的实现代码：

#pragma once

#include <iostream>
#include <map>
#include <list>

template<typename K, typename V>
struct Node {
    K key_;
    V val_;
};

template<typename K, typename V>
class LRUCache {
public:
    using NodeType = Node<K,V>;

    LRUCache(uint32_t cap): cap_(cap){}

    ~LRUCache() {
        std::map<K, NodeType*> temp;
        temp.swap(cache_);
        while (!data_.empty()) {
            auto o = data_.pop_back();
            delete o;
        }
        cap_ = 0;
    }
    void Put(NodeType* node) {
        //在cache_中查找
        auto iter = cache_.find(node->key_);
        if (iter == cache_.end()) {
            NodeType *temp = new NodeType(node->key_, node->val_);
            cache_[temp->key_] = temp;
            data_.push_front(temp);
        } else {
            iter->second->value = node->val_;
            data_.erase(iter->second);
            data_.push_front(iter->second);
        }

        if (data_.size() > cap_) {
            auto temp = data_.pop_back();
            cache_.erase(temp->key);
            delete temp;
        }
    }

    NodeType * Get(K k) {
        auto iter = cache_.find(node->key_);
        if (iter == cache_.end()) {
            return nullptr;
        }

        data_.erase(iter->second);
        data_.push_front(iter->second);
        return iter->second;
    }



private:
    
    std::list<NodeType*>   data_;
    uint32_t   cap_ = 0;
    std::map<K, NodeType*> cache_;
};