{"id":110535,"date":"2024-11-18T07:00:00","date_gmt":"2024-11-18T15:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=110535"},"modified":"2024-11-18T09:48:36","modified_gmt":"2024-11-18T17:48:36","slug":"20241118-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20241118-00\/?p=110535","title":{"rendered":"The operations for reading and writing single elements for C++ standard library maps"},"content":{"rendered":"

Some time ago, I noted that the std::map<\/code> subscript operator is an attractive nuisance<\/a>. It is the most convenient syntax, but is not often what you actually want.<\/p>\n

I’ve broken down the various std::map<\/code> lookup and update operations into a table so you can choose the best one for your situation.<\/p>\n\n\n\n\n\n\n\n\n\n
Operation<\/th>\nMethod<\/th>\n<\/tr>\n
Read, throw if missing<\/td>\nm.at(key)<\/tt><\/td>\n<\/tr>\n
Read, allow missing<\/td>\nm.find(key)<\/tt><\/td>\n<\/tr>\n
Read, create if missing<\/td>\nm[key]<\/tt><\/td>\n<\/tr>\n
Write, nop if exists, discard value<\/td>\nm.insert({ key, value })<\/tt>
\nm.emplace(key, value)<\/tt><\/td>\n<\/tr>\n
Write, nop if exists<\/td>\nm.emplace(std::piecewise_construct<\/a>, ...)<\/tt>
\nm.try_emplace(key, params)<\/tt><\/td>\n<\/tr>\n
Write, overwrite if exists<\/td>\nm.insert_or_assign(key, value)<\/tt><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

In the table above, key<\/code> is the map key, value<\/code> is the mapped type, and params<\/code> are parameters to the mapped type constructor.<\/p>\n

Note that insert<\/code> and the first emplace<\/code>\u00b9 take a value which is discarded if it turns out that the key already exists. This is undesirable if creating the value is expensive.<\/p>\n

One frustrating scenario is the case where the mapped type’s default constructor is not the constructor you want to use for operator[]<\/code>, or if you want the initial mapped value to be the result of a function call rather than a constructor. Here’s something I sort of threw together.<\/p>\n

template<typename Map, typename Key, typename Maker>\r\nauto& ensure(Map&& map, Key&& key, Maker&& maker)\r\n{\r\n    auto lower = map.lower_bound(key);\r\n    if (lower == map.end() || !map.key_comp()(lower->first, key)) {\r\n        lower = map.emplace_hint(lower, std::forward<Key>(key),\r\n                                 std::forward<Maker>(maker)());\r\n    }\r\n    return lower->second;\r\n}\r\n<\/pre>\n
This returns a reference to the mapped value that corresponds to the provided key, creating one if necessary via the maker<\/code>. We forward the key into emplace_hint<\/code> so it can be moved.<\/p>\n
struct Widget\r\n{\r\n    Widget(std::string name);\r\n\r\n    \u27e6 ... other stuff ... \u27e7\r\n};\r\nstd::map<std::string, std::shared_ptr<Widget>> widgets;\r\n\r\nauto& ensure_named_widget(std::string const& name)\r\n{\r\n    return ensure(widgets, name,\r\n        [&] { return std::make_shared<Widget>(name); });\r\n}\r\n<\/pre>\n
As a convenience, we can accept bonus parameters which are passed to the maker<\/code>. This allows you to parameterize the maker<\/code>.<\/p>\n
template<typename Map, typename Key, typename... Maker>\r\nauto& ensure(Map&& map, Key&& key, Maker&&... maker)\r\n{\r\n    auto lower = map.lower_bound(key);\r\n    if (lower == map.end() || map.key_comp()(lower->first, key)) {\r\n        lower = map.emplace_hint(lower, std::forward<Key>(key),\r\n            std::invoke(std::forward<Maker>(maker)...));\r\n    }\r\n    return lower->second;\r\n}\r\n\r\nauto& ensure_named_widget(std::string const& name)\r\n{\r\n    return ensure(widgets, name,\r\n        [](auto&& name) { return std::make_shared<Widget>(name); },\r\n        name);\r\n}\r\n\r\n\/\/ or\r\n\r\nauto shared_widget_maker(std::string const& name)\r\n{\r\n    return std::make_shared<Widget>(name);\r\n}\r\n\r\nauto& ensure_named_widget(std::string const& name)\r\n{\r\n    return ensure(widgets, name, shared_widget_maker, name);\r\n}\r\n<\/pre>\n
But wait, we learned last time that  conversion operators are in play<\/a>. We can use our EmplaceHelper<\/code> in conjunction with try_emplace<\/code>.<\/p>\n
template<typename Map, typename Key, typename... Maker>\r\nauto& ensure(Map&& map, Key&& key, Maker&&... maker)\r\n{\r\n    return *map.try_emplace(key, EmplaceHelper([&] {\r\n        return std::invoke(std::forward<Maker>(maker)...);\r\n    }).first;\r\n}\r\n<\/pre>\n
The try_emplace<\/code> function returns a std::pair<\/code> of an iterator to the matching item (either pre-existing or freshly-created) and a bool<\/code> that indicates whether the item is freshly-created. We don’t care about whether the item is freshly-created, so we just take the iterator (the .first<\/code>) and dereference it to get a reference to the item.<\/p>\n
This is simple enough that you might just write it out rather than calling out to a one-liner helper.<\/p>\n
auto& item =\r\n    *widgets.try_emplace(name, EmplaceHelper([&] {\r\n        return std::make_shared<Widget>(name); }).first;\r\n\r\n\/\/ or\r\n\r\nauto& item =\r\n    *widgets.try_emplace(name,\r\n        EmplaceHelper(shared_widget_maker, name)).first;\r\n<\/pre>\n
\u00b9 Technically, you can pass the first emplace<\/code> a second parameter that is used to construct<\/i> the value<\/code>, so if your mapped type has a single-parameter constructor, you can use the first emplace<\/code> to get the same effect as the piecewise constructor: on-demand construction of the mapped type.<\/p>\n","protected":false},"excerpt":{"rendered":"
Breaking down the options.<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[25],"class_list":["post-110535","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Breaking down the options.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/110535","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/users\/1069"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/comments?post=110535"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/110535\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media\/111744"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media?parent=110535"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=110535"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=110535"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}