C++ unordered_map, efficient lazy load and use of value

Question

I want to use lazy loading of an unordered_map. I search the map for a key. If it exists I use the value. If it doesn't exist I create the value and emplace the key,value pair.

I want to avoid the last map.find() statement - it should be an unnecessary operation (performance is important). It might fail :-( and I'd hope for a better solution.

Note: The calling routine should only have a const reference to value. Avoid instantiation of value in calling routine.

How can I avoid the second lookup AND have a properly scoped const reference returned to the caller ?

h file

`    typedef std::vector DataPtrListVector;
    struct DataCacheStruct
    {
        DataPtrListVector dataItemOne;
    };
    typedef boost::unordered_map DataCacheMap;
    // declare instance variable
    DataCacheMap dataCacheMap;
    // declare function
    const DataCacheStruct& getOrCreateData( const std::string& dataKey,... );`

cpp file

`    // Lazy Load of DataStruct unordered_map
    std::string key = someString;
    const DataCacheStruct& dataStruct = getOrCreateData( key, ... );


    //
    const DataCacheStruct& class::getOrCreateData( const std::string key, ...)
    {
        DataCacheMap::const_iterator itData = dataCacheMap.find(key);
        if (itData != dataCacheMap.end())
        {
            return itData->second;
        }
        DataCacheStruct newData = doSomethingSlow();
        dataCacheMap.emplace(std::make_pair(key, newData));
        // Now I want to return newData as a const reference, as per unordered_map
        // but it goes out of scope before the calling routine can use it.
        DataCacheMap::const_iterator itData = dataCacheMap.find(key);
        return itData->second;
    }`

emplace returns the iterator where the element has been inserted — BiagioF
– BiagioF, Commented Sep 17, 2016 at 9:50

BiagioF · Accepted Answer · 2016-09-17 09:53:39Z

2

As I've already said, the method emplace, returns a pair of an iterator to the newly inserted element and a value of true.

You can simply use that iterator, to get a reference:

auto it_new_insertion = dataCacheMap.emplace(std::make_pair(key, newData));
if (it_new_insertion.second == false) {  
 // something wrong with memory. handle it
}
return it_new_insertion.first->second;

answered Sep 17, 2016 at 9:53

BiagioF

9,7952 gold badges30 silver badges54 bronze badges

Sign up to request clarification or add additional context in comments.

Collectives™ on Stack Overflow

C++ unordered_map, efficient lazy load and use of value

1 Answer 1

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Related