std::unordered_map<Key,T,Hash,KeyEqual,Allocator>::insert_or_assign - cppreference.com (original) (raw)

1,4) If a key equivalent to k already exists in the container, assigns std::forward<M>(obj) to the mapped_type corresponding to the key k. If the key does not exist, inserts the new value as if by insert, constructing it from value_type(k, std::forward<M>(obj)).

2,5) Same as (1,4), except the mapped value is constructed from value_type(std::move(k), std::forward<M>(obj)).

3,6) If a key equivalent to k already exists in the container, assigns std::forward<M>(obj) to the mapped_type corresponding to the key k. If the key does not exist, constructs an object u of value_type with std::forward<K>(k), std::forward<M>(obj)), then inserts u into *this. If hash_function()(u.first) != hash_function()(k) || contains(u.first) is true, the behavior is undefined. The value_type must be EmplaceConstructible into unordered_map from std::forward<K>(k), std::forward<M>(obj). This overload participates in overload resolution only if Hash and KeyEqual are both transparent. This assumes that such Hash is callable with both K and Key type, and that the KeyEqual is transparent, which, together, allows calling this function without constructing an instance of Key.

The behavior is undefined(until C++20)The program is ill-formed(since C++20) if std::is_assignable_v<mapped_type&, M&&> is false.

If after the operation the new number of elements is greater than old max_load_factor() * bucket_count() a rehashing takes place.
If rehashing occurs (due to the insertion), all iterators are invalidated. Otherwise (no rehashing), iterators are not invalidated.

[edit] Parameters

[edit] Return value

1-3) The bool component is true if the insertion took place and false if the assignment took place. The iterator component is pointing at the element that was inserted or updated.

4-6) Iterator pointing at the element that was inserted or updated.

[edit] Complexity

[edit] Notes

insert_or_assign returns more information than operator[] and does not require default-constructibility of the mapped type.

[edit] Example

#include #include #include   void print_node(const auto& node) { std::cout << '[' << node.first << "] = " << node.second << '\n'; }   void print_result(auto const& pair) { std::cout << (pair.second ? "inserted: " : "assigned: "); print_node(*pair.first); }   int main() { std::unordered_map<std::string, std::string> myMap;   print_result(myMap.insert_or_assign("a", "apple")); print_result(myMap.insert_or_assign("b", "banana")); print_result(myMap.insert_or_assign("c", "cherry")); print_result(myMap.insert_or_assign("c", "clementine"));   for (const auto& node : myMap) print_node(node); }

Possible output:

inserted: [a] = apple inserted: [b] = banana inserted: [c] = cherry assigned: [c] = clementine [c] = clementine [a] = apple [b] = banana

[edit] See also

| | access or insert specified element (public member function) [edit] | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | | access specified element with bounds checking (public member function) [edit] | | | inserts elements or nodes(since C++17) (public member function) [edit] | | | constructs element in-place (public member function) [edit] |