Namespaces
Variants

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

From cppreference.net

C++
Containers library
std::map
Member functions
Non-member functions
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20)
Deduction guides (C++17)
template < class ... Args >
std:: pair < iterator, bool > try_emplace ( const Key & k, Args && ... args ) ;
(1) (desde C++17)
template < class ... Args >
std:: pair < iterator, bool > try_emplace ( Key && k, Args && ... args ) ;
(2) (desde C++17)
template < class K, class ... Args >
std:: pair < iterator, bool > try_emplace ( K && k, Args && ... args ) ;
(3) (desde C++26)
template < class ... Args >
iterator try_emplace ( const_iterator hint, const Key & k, Args && ... args ) ;
(4) (desde C++17)
template < class ... Args >
iterator try_emplace ( const_iterator hint, Key && k, Args && ... args ) ;
(5) (desde C++17)
template < class K, class ... Args >
iterator try_emplace ( const_iterator hint, K && k, Args && ... args ) ;
(6) (desde C++26)

Si ya existe una clave equivalente a k en el contenedor, no hace nada. De lo contrario, inserta un nuevo elemento en el contenedor con clave k y valor construido con args . En tal caso:

1) Se comporta como emplace excepto que el elemento se construye como
value_type ( std:: piecewise_construct ,

std:: forward_as_tuple ( k ) ,

std:: forward_as_tuple ( std:: forward < Args > ( args ) ... ) )
2) Se comporta como emplace excepto que el elemento se construye como
value_type ( std:: piecewise_construct ,

std:: forward_as_tuple ( std :: move ( k ) ) ,

std:: forward_as_tuple ( std:: forward < Args > ( args ) ... ) )
3) Se comporta como emplace excepto que el elemento se construye como
value_type ( std:: piecewise_construct ,

std:: forward_as_tuple ( std:: forward < K > ( k ) ) ,

std:: forward_as_tuple ( std:: forward < Args > ( args ) ... ) )
4) Se comporta como emplace_hint excepto que el elemento se construye como
value_type ( std:: piecewise_construct ,

std:: forward_as_tuple ( k ) ,

std:: forward_as_tuple ( std:: forward < Args > ( args ) ... ) )
5) Se comporta como emplace_hint excepto que el elemento se construye como
value_type ( std:: piecewise_construct ,

std:: forward_as_tuple ( std :: move ( k ) ) ,

std:: forward_as_tuple ( std:: forward < Args > ( args ) ... ) )
6) Se comporta como emplace_hint excepto que el elemento se construye como
value_type ( std:: piecewise_construct ,

std:: forward_as_tuple ( std:: forward < K > ( k ) ) ,

std:: forward_as_tuple ( std:: forward < Args > ( args ) ... ) )
1-6) Si value_type no es EmplaceConstructible en el map desde la expresión correspondiente, el comportamiento es indefinido.
3) Esta sobrecarga participa en la resolución de sobrecarga solo si se cumplen todas las siguientes condiciones:
Si equal_range ( u. first ) == equal_range ( k ) es false , el comportamiento es indefinido, donde u es el nuevo elemento a insertar.
6) Esta sobrecarga participa en la resolución de sobrecarga solo si el identificador calificado Compare :: is_transparent es válido y denota un tipo.
Si equal_range ( u. first ) == equal_range ( k ) es false , el comportamiento es indefinido, donde u es el nuevo elemento a insertar.

No se invalidan iteradores ni referencias.

Contenidos

Parámetros

k - la clave utilizada tanto para buscar como para insertar si no se encuentra
hint - iterador a la posición antes de la cual se insertará el nuevo elemento
args - argumentos para reenviar al constructor del elemento

Valor de retorno

1-3) Igual que para emplace :
Un par que consiste en un iterador al elemento insertado (o al elemento que impidió la inserción) y un valor bool establecido en true si y solo si la inserción tuvo lugar.
4-6) Lo mismo que para emplace_hint :
Un iterador al elemento insertado, o al elemento que impidió la inserción.

Complejidad

1-3) Igual que para emplace :
Logarítmico en el tamaño del contenedor.
4-6) Igual que para emplace_hint :
Logarítmico en el tamaño del contenedor en general, pero constante amortizado si el nuevo elemento se inserta justo antes de hint .

Notas

A diferencia de insert o emplace , estas funciones no mueven argumentos rvalue si la inserción no ocurre, lo que facilita manipular mapas cuyos valores son tipos de solo movimiento, como std:: map < std:: string , std:: unique_ptr < foo >> . Además, try_emplace trata la clave y los argumentos para el mapped_type por separado, a diferencia de emplace , que requiere argumentos para construir un value_type (es decir, un std::pair ).

Sobrecargas ( 3 ) y ( 6 ) pueden ser llamadas sin construir un objeto de tipo Key .

Macro de prueba de características Valor Std Característica
__cpp_lib_map_try_emplace 201411L (C++17) std::map::try_emplace , std::map::insert_or_assign
__cpp_lib_associative_heterogeneous_insertion 202311L (C++26) Sobrecargas heterogéneas para las funciones miembro restantes en contenedores asociativos ordenados y contenedores asociativos no ordenados. Sobrecargas ( 3 ) y ( 6 ) .

Ejemplo

Ejecutar este código 
#include <iostream>
#include <string>
#include <map>
#include <utility>
void print_node(const auto& node)
{
    std::cout << '[' << node.first << "] = " << node.second << '\n';
}
void print_result(auto const& pair)
{
    std::cout << (pair.second ? "inserted: " : "ignored:  ");
    print_node(*pair.first);
}
int main()
{
    using namespace std::literals;
    std::map<std::string, std::string> m;
    print_result(m.try_emplace("a", "a"s));
    print_result(m.try_emplace("b", "abcd"));
    print_result(m.try_emplace("c", 10, 'c'));
    print_result(m.try_emplace("c", "Won't be inserted"));
    for (const auto& p : m)
        print_node(p);
}

Salida: 

inserted: [a] = a
inserted: [b] = abcd
inserted: [c] = cccccccccc
ignored:  [c] = cccccccccc
[a] = a
[b] = abcd
[c] = cccccccccc

Véase también

(C++11)
construye elementos en el lugar
(función miembro pública)
(C++11)
construye elementos en el lugar usando una pista
(función miembro pública)
inserta elementos o nodos (since C++17)
(función miembro pública)