# std::map<Key,T,Compare,Allocator>::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(std::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(std::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(std::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(std::forward<Args>(args)...))`

No iterators or references are invalidated.

### 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

### Return value

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

### Complexity

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

### 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`)

### Example

Run this code

    #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');
        m.try_emplace("c", "Won't be inserted");

        for (const auto &p : m) {
            std::cout << p.first << " => " << p.second << '\n';
        }
    }

Output:

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

### See also

emplace (C++11) | constructs element in-place (public member function)
emplace_hint (C++11) | constructs elements in-place using a hint (public member function)
insert | inserts elements or nodes (since C++17) (public member function)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/container/map/try_emplace&oldid=74454"