RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://en.cppreference.com/w/cpp/algorithm/../../cpp/container/array/../map/insert_or_assign.html below:

std::map<Key,T,Compare,Allocator>::insert_or_assign - cppreference.com

template< class M > std::pair<iterator, bool> insert_or_assign( const Key& k, M&& obj ); (1) (since C++17) template< class M > std::pair<iterator, bool> insert_or_assign( Key&& k, M&& obj ); (2) (since C++17) template< class K, class M > std::pair<iterator, bool> insert_or_assign( K&& k, M&& obj ); (3) (since C++26)

template< class M > iterator insert_or_assign( const_iterator hint, const Key& k, M&& obj );

(4) (since C++17)

template< class M > iterator insert_or_assign( const_iterator hint, Key&& k, M&& obj );

(5) (since C++17)

template< class K, class M > iterator insert_or_assign( const_iterator hint, K&& k, M&& obj );

(6) (since C++26) 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

value_type

with

std::forward<K>(k), std::forward<M>(obj))

, then inserts

u

into

*this

. If

equal_range(u.first) == equal_range(k)

false

, the behavior is undefined. The

value_type

must be

EmplaceConstructible

into

map

from

std::forward<K>(k), std::forward<M>(obj)

. This overload participates in overload resolution only if

Compare

transparent

. It 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.

No iterators or references are invalidated.

[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 obj - the value to insert or assign [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 <iostream>
#include <string>
#include <map>
 
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::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);
}

Output:

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

[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]

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4