Namespaces
Variants

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

From cppreference.net

C++
Containers library
std::unordered_map
Member types
Member functions
Non-member functions
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 unordered_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 hash_function ( ) ( u. first ) ! = hash_function ( ) ( k ) || contains ( u. first ) es true , el comportamiento es indefinido, donde u es el nuevo elemento a insertar.
6) Esta sobrecarga participa en la resolución de sobrecarga solo si Hash :: is_transparent y KeyEqual :: is_transparent son ambos válidos y cada uno denota un tipo.
Si hash_function ( ) ( u. first ) ! = hash_function ( ) ( k ) || contains ( u. first ) es true , el comportamiento es indefinido, donde u es el nuevo elemento a insertar.

Si después de la operación el nuevo número de elementos es mayor que el antiguo max_load_factor() * bucket_count() se produce una redistribución.
Si ocurre redistribución (debido a la inserción), todos los iteradores quedan invalidados. En caso contrario (sin redistribución), los iteradores no se invalidan.

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) Igual que para emplace_hint :
Un iterador al elemento insertado, o al elemento que impidió la inserción.

Complejidad

1-3) Igual que para emplace :
Constante amortizado en promedio, caso lineal en el peor caso en función del tamaño del contenedor.
4-6) Igual que para emplace_hint :
Amortizado constante en promedio, caso lineal en el peor de los casos en función del tamaño del contenedor.

Notas

A diferencia de insert o emplace , estas funciones no mueven argumentos rvalue si la inserción no ocurre, lo que facilita la manipulación de mapas cuyos valores son tipos de solo movimiento, como std:: unordered_map < std:: string , std:: unique_ptr < foo >> . Además, try_emplace trata la clave y los argumentos del 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_unordered_map_try_emplace 201411L (C++17) std::unordered_map::try_emplace ,
std::unordered_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 <unordered_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::unordered_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 posible: 

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

Véase también

construye elementos in-situ
(función miembro pública)
construye elementos in-situ usando una pista
(función miembro pública)
inserta elementos o nodos (desde C++17)
(función miembro pública)