std::map<Key,T,Compare,Allocator>::emplace

template< class... Args > std::pair<iterator,bool> emplace( Args&&... args );		(since C++11)

Inserts a new element into the container constructed in-place with the given args if there is no element with the key in the container.

Careful use of emplace allows the new element to be constructed while avoiding unnecessary copy or move operations. The constructor of the new element (i.e. std::pair<const Key, T>) is called with exactly the same arguments as supplied to emplace, forwarded via std::forward<Args>(args).... The element may be constructed even if there already is an element with the key in the container, in which case the newly constructed element will be destroyed immediately.

No iterators or references are invalidated.

Parameters

args

-

arguments to forward to the constructor of the element

Return value

Returns a pair consisting of an iterator to the inserted element, or the already-existing element if no insertion happened, and a bool denoting whether the insertion took place. True for Insertion, False for No Insertion.

Exceptions

If an exception is thrown by any operation, this function has no effect.

Complexity

Logarithmic in the size of the container.

Example

Run this code

#include <iostream>
#include <utility>
#include <string>
#include <map>
 
int main()
{
    std::map<std::string, std::string> m;
 
    // uses pair's move constructor
    m.emplace(std::make_pair(std::string("a"), std::string("a")));
 
    // uses pair's converting move constructor
    m.emplace(std::make_pair("b", "abcd"));
 
    // uses pair's template constructor
    m.emplace("d", "ddd");
 
    // uses pair's piecewise constructor
    m.emplace(std::piecewise_construct,
              std::forward_as_tuple("c"),
              std::forward_as_tuple(10, 'c'));
    // as of C++17, m.try_emplace("c", 10, 'c'); can be used
 
    for (const auto &p : m) {
        std::cout << p.first << " => " << p.second << '\n';
    }
}

Output:

a => a
b => abcd
c => cccccccccc
d => ddd

Language
Standard Library Headers
Freestanding and hosted implementations
Named requirements
Language support library
Concepts library (C++20)
Diagnostics library
Utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Input/output library
Localizations library
Regular expressions library (C++11)
Atomic operations library (C++11)
Thread support library (C++11)
Filesystem library (C++17)
Technical Specifications

array (C++11)
vector
deque
forward_list (C++11)
list
set
multiset
map
multimap
unordered_set (C++11)
unordered_multiset (C++11)
unordered_map (C++11)
unordered_multimap (C++11)
stack
queue
priority_queue
span (C++20)

Member functions
map::map
map::~map
map::operator=
map::get_allocator
Element access
map::at
map::operator[]
Iterators
map::beginmap::cbegin (C++11)
map::endmap::cend (C++11)
map::rbeginmap::crbegin (C++11)
map::rendmap::crend (C++11)
Capacity
map::empty
map::size
map::max_size
Modifiers
map::clear
map::insert
map::insert_or_assign (C++17)
map::emplace (C++11)
map::emplace_hint (C++11)
map::try_emplace (C++17)
map::erase
map::swap
map::extract (C++17)
map::merge (C++17)
Lookup
map::count
map::find
map::contains (C++20)
map::equal_range
map::lower_bound
map::upper_bound
Observers
map::key_comp
map::value_comp
Deduction guides(C++17)