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_;
};