std::map::emplace

From cppreference.com

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

Inserts a new element to the container. The element is constructed in-place, i.e. no copy or move operations are performed. The constructor of the element type (value_type, that is, std::pair<const Key, T>) is called with exactly the same arguments as supplied to the function, forwarded with std::forward<Args>(args)....

No iterators or references are invalidated.

Contents

[edit] Parameters

args - arguments to forward to the constructor of the element

[edit] Return value

returns a pair consisting of a bool denoting whether the insertion took place and an iterator to the inserted element, or the already-existing element if no insertion happened.

[edit] Complexity

Logarithmic in the size of the container.

[edit] Example

#include <iostream>
#include <utility>
#include <map>
 
int main()
{
    std::map<std::string, std::string> m;
 
    // uses pair's copy-constructor
    m.emplace(std::make_pair(std::string("a"), std::string("a")));
 
    // uses pair's converting copy 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'));
 
    for (const auto &p : m) {
        std::cout << p.first << " => " << p.second << '\n';
    }
}

Output:

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

[edit] See also

(C++11)
constructs elements in-place using a hint
(public member function)
inserts elements
(public member function)