sexy-af.cpp

#include <memory>
#include <map>

template<typename Key, typename Value>
class WeakCache {

public:
    template<typename... Args>
    WeakCache(Args&&... args)
         : cache_(std::forward<Args>(args)...) {}

    std::shared_ptr<Value> operator[] (const Key& key) {
        auto& value = cache_[key];
        auto ptr = value.lock();
        if(ptr)
            return ptr;
        value = ptr = std::make_shared<Value>(key);
        return ptr;
    }

private:
    std::map<Key, std::weak_ptr<Value>> cache_;

};

This acts as a cache of objects that will create the object when you request it,
or if the object already exists (and hasn't been deleted), will return the existing object. 
Good for immutable objects coming from resources files. For example, 
in my usage I had an immutable Dictionary object which had a set of built in word list configurations,
expressed as a Dictionary::Config enum. To create an dictionary, one could simply call Dictionary::Create(config), 
which looks like:

shared_ptr<Dictionary> Dictionary::Create(Config config) {
    return dictionaryCache[config];
}

If the dictionary object already exists and hasn't been deleted, you get it. Otherwise, the dictionary would get created anew. This was particularly good because dictionaries are expensive to read in and setup.