LRU cache

Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.

get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
set(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.

class LRUCache{
public:
    LRUCache(int capacity) {
        max_capacity = capacity;
        cur_size = 0;
    }
    
    int get(int key) {
        int value;
        if (hash.find(key) == hash.end()) {
            return -1;
        }
        else {
            auto it = hash[key];
            value = it->second;
            cache.push_front(*it);
            cache.erase(it); // delete
            
            hash[key] = cache.begin();
        }
        return value;
    }
    
    void set(int key, int value) {
           
        if (hash.find(key) != hash.end()) {
            cache.erase(hash[key]);
            hash.erase(key);        
        }
        else {
            if (cur_size < max_capacity) {
                cur_size++;
            }
            else {
                // delete old (key,value)
                list<pair<int,int> >::iterator it = cache.begin();
                advance(it, cur_size-1);
                hash.erase(it->first);
                cache.erase(it);
            }
        }
            
        cache.push_front(pair<int,int>(key,value));
        hash[key] = cache.begin();
    }

private:
    int max_capacity;
    int cur_size;
    list<pair<int,int> > cache;
    unordered_map<int, list<pair<int,int> >::iterator> hash;
};