避免在map / unordered_map中进行多次查找

Question

Let's say we have an expensive function mapping string to int and want to cache results in a map.

The simplest code would be

int mapStringToIntWithCache(std::string const& s) {
    static std::unordered_map<std::string, int> cache;
    if (cache.count(s) > 0) return cache[s];
    else return cache[s] = myExpensiveFunction(s);
}

But this has 2 lookups.

I therefore tend to write this

int mapStringToIntWithCache(std::string const& s) {
    static std::unordered_map<std::string, int> cache;
    size_t sizeBefore = cache.size();
    int& val = cache[s];
    if (cache.size() > sizeBefore) val = myExpensiveFunction(s);
    return val;
}

This has only one lookup, but seems a little clumsy. Is there a better way?

Answer 1

Just use std::map::emplace() method:

int mapStringToIntWithCache(std::string const& s) {
    static std::unordered_map<std::string, int> cache;
    auto pair = cache.emplace( s, 0 );
    if( pair.second )
         pair.first->second = myExpensiveFunction(s);
    return pair.first->second;
}

Answer 2

Just a note to the @Slava's answer: If you pass argument by const lvalue reference, you cannot move then from this argument if it's rvalue:

int i = mapStringToIntWithCache("rvalue argument here");

The temporary std::string argument will be copied here if insertion to cache takes place.

You can use perfect forwarding , however, if you want to maintain arguments to be of std::string type only (eg, for implicit conversions from string literals), then you need some wrapper-helper function solution:

template <typename T>
int mapStringToIntWithCacheHelper(T&& s) {
  static std::unordered_map<std::string, int> cache;
  auto pair = cache.emplace( std::forward<T>(s), 0 );
  if( pair.second )
    pair.first->second = myExpensiveFunction(pair.first->first); // can't use s here !!!
  return pair.first->second;
}

int mapStringToIntWithCache(const std::string & s) {
  mapStringToIntWithCacheHelper(s);
}

int mapStringToIntWithCache(std::string && s) {
  mapStringToIntWithCacheHelper(std::move(s));
}