Namespaces
Variants
Views
Actions

std::map::try_emplace

From cppreference.com
< cpp‎ | container‎ | map
template <class... Args>
pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
(1) (since C++17)
template <class... Args>
pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
(2) (since C++17)
template <class... Args>
iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
(3) (since C++17)
template <class... Args>
iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
(4) (since C++17)
1) If a key equivalent to k already exists in the container, does nothing. Otherwise, behaves like emplace except that the element is constructed as value_type(std::piecewise_construct, std::forward_as_tuple(k), std::forward_as_tuple(forward<Args>(args)...))
2) If a key equivalent to k already exists in the container, does nothing. Otherwise, behaves like emplace except that the element is constructed as value_type(std::piecewise_construct, std::forward_as_tuple(std::move(k)), std::forward_as_tuple(forward<Args>(args)...))
3) If a key equivalent to k already exists in the container, does nothing. Otherwise, behaves like emplace_hint except that the element is constructed as value_type(std::piecewise_construct, std::forward_as_tuple(k), std::forward_as_tuple(forward<Args>(args)...))
4) If a key equivalent to k already exists in the container, does nothing. Otherwise, behaves like emplace_hint except that the element is constructed as value_type(std::piecewise_construct, std::forward_as_tuple(std::move(k)), std::forward_as_tuple(forward<Args>(args)...))

No iterators or references are invalidated.

Contents

[edit] Parameters

k - the key used both to look up and to insert if not found
hint - iterator to the position before which the new element will be inserted
args - arguments to forward to the constructor of the element

[edit] Return value

1,2) Same as for emplace
3,4) Same as for emplace_hint

[edit] Complexity

1,2) Same as for emplace
3,4) Same as for emplace_hint

[edit] Notes

Unlike insert or emplace, these functions do not move from rvalue arguments if the insertion does not happen, which makes it easy to manipulate maps whose values are move-only types, such as std::map<std::string, std::unique_ptr<foo>>. In addition, try_emplace treats the key and the arguments to the mapped_type separately, unlike emplace, which requires the arguments to construct a value_type (that is, a std::pair)

[edit] Example

#include <iostream>
#include <utility>
#include <string>
 
#include <map>
int main()
{
    using namespace std::literals;
    std::map<std::string, std::string> m;
 
    m.try_emplace("a", "a"s);
    m.try_emplace("b", "abcd");
    m.try_emplace("c", 10, 'c');
 
    for (const auto &p : m) {
        std::cout << p.first << " => " << p.second << '\n';
    }
}

Output:

a => a
b => abcd
c => cccccccccc

[edit] See also

(C++11)
constructs element in-place
(public member function) [edit]
constructs elements in-place using a hint
(public member function) [edit]
inserts elements or nodes (since C++17)
(public member function) [edit]