std::unordered_map<Key,T,Hash,KeyEqual,Allocator>::insert

Since C++11

Inserts element(s) into the container, if the container doesn’t already contain an element with an equivalent key.

# Declarations

std::pair<iterator, bool> insert( const value_type& value );

(since C++11)

std::pair<iterator, bool> insert( value_type&& value );

(since C++17)

template< class P >
std::pair<iterator, bool> insert( P&& value );

(since C++11)

iterator insert( const_iterator hint, const value_type& value );

(since C++11)

iterator insert( const_iterator hint, value_type&& value );

(since C++17)

template< class P >
iterator insert( const_iterator hint, P&& value );

(since C++11)

template< class InputIt >
void insert( InputIt first, InputIt last );

(since C++11)

void insert( std::initializer_list<value_type> ilist );

(since C++11)

insert_return_type insert( node_type&& nh );

(since C++17)

iterator insert( const_iterator hint, node_type&& nh );

(since C++17)

# Parameters

# Notes

The hinted insert (4-6) does not return a boolean in order to be signature-compatible with positional insert on sequential containers, such as std::vector::insert. This makes it possible to create generic inserters such as std::inserter. One way to check success of a hinted insert is to compare size() before and after.

# Example

#include <iostream>
#include <string>
#include <unordered_map>
 
int main ()
{
    std::unordered_map<int, std::string> dict = {{1, "one"}, {2, "two"}};
    dict.insert({3, "three"});
    dict.insert(std::make_pair(4, "four"));
    dict.insert({{4, "another four"}, {5, "five"}});
 
    const bool ok = dict.insert({1, "another one"}).second;
    std::cout << "inserting 1 => \"another one\" "
              << (ok ? "succeeded" : "failed") << '\n';
 
    std::cout << "contents:\n";
    for (auto& p : dict)
        std::cout << ' ' << p.first << " => " << p.second << '\n';
}

# Defect reports

DRApplied toBehavior as publishedCorrect behavior
LWG 2005C++11overloads (3,6) would only participate in overloadresolution if P is implicitly convertible to value_typeonly participates if value_typeis constructible from P&&

# See also