STL 容器 find_or_create()

Question

Is there some sort of STL facility for doing a find_or_create() on STL containers?

Eg in the case of unordered_map, I frequently find myself needing to retrieve some value and create it if no value exists. There are plenty of functions for conditionally inserting into a map, but all of them result in creating a new value right away, even if one is already present in the map:

#include <iostream>
#include <unordered_map>

struct A {
        A() = default;

        A(std::string_view method) {
                std::cout << "Created via " << method << std::endl;
        }
};

int main() {
        std::unordered_map<int, A> m{
                {0, A{}}
        };

        // Get a reference to m[0]; create it if it doesn't exist
        // Key 0 is already in the map, so these calls *should* do little work
        auto &val1 = *m.insert(std::make_pair(0, A{"insert"})).first;
        auto &val2 = *m.emplace(0, A{"emplace"}).first;
        auto &val3 = *m.emplace(std::piecewise_construct,
                        std::make_tuple(0),
                        std::make_tuple("piecewise construct")).first;
        auto &val4 = *m.try_emplace(0, A{"try_emplace"}).first;
        auto &val5 = (m[0] = A{"operator[]"});

        return 0;
}

Output:

Created via insert
Created via emplace
Created via piecewise construct
Created via try_emplace
Created via operator[]

In the event that object A is costly to create (takes a long time to construct, acquires system resources, etc.) these unnecessary creations can be undesirable. This often leads me to create a template like so:

#include <iostream>
#include <unordered_map>

struct A {
        A() = default;

        A(std::string_view method) {
                std::cout << "Created via " << method << std::endl;
        }
};

template<class Map, class OnCreate>
typename Map::mapped_type &find_or_create(Map &map, const typename Map::key_type &key, const OnCreate &on_create) {
        auto it = map.find(key);
        if (it == map.end())
                it = map.emplace(key, on_create(key)).first;
        return it->second;
}

int main() {
        std::unordered_map<int, A> m;

        // Get a reference to m[0]; create it if it doesn't exist
        auto &val1 = find_or_create(m, 0, [](const int &) { return A{"find_or_create"}; });
        auto &val2 = find_or_create(m, 0, [](const int &) { return A{"never created"}; });
        return 0;
}

Output:

Created via find_or_create

Is there a better (ie simpler) way to achieve this via STL, or is a template like this one the way to go?

Answer 1

try_emplace is what you want. Your problem is that you are deliberately constructing an A , instead of passing the arguments to the constructor, which it may or may not use to construct the A .

What you want is this:

auto &val4 = *m.try_emplace(0, "try_emplace").first;

Your find-or-create function would be useful if you can't create the object via constructor call (ie: instances get created via factory functions or whatever).