Espacios de nombres
Variantes

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

    De cppreference.com
    See More

    [edit template]
     
    C++
    Apoyo de compiladores
    Implementaciones independientes y albergadas
    Lenguaje
    Biblioteca estándar
    Encabezados de la biblioteca estándar
    Requisitos denominados
    Macros de prueba de característica (C++20)
    Biblioteca de apoyo del lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnósticos
    Biblioteca de gestión de memoria
    Biblioteca de metaprogramación (C++11)
    Biblioteca de servicios generales
    Biblioteca de contenedores
    Biblioteca de iteradores
    Biblioteca de rangos (C++20)
    Biblioteca de algoritmos
    Biblioteca de cadenas
    Biblioteca de procesamiento de texto
    Biblioteca numérica
    Biblioteca de fecha y hora
    Biblioteca de entrada/salida
    Biblioteca del sistema de archivos (C++17)
    Biblioteca de apoyo de concurrencia (C++11)
    Biblioteca de apoyo de ejecución (C++26)
    Especificaciones técnicas
    Índice de símbolos
    Bibliotecas externas
     
    Biblioteca de contenedores
     
    std::unordered_map
    Funciones miembro
    Iteradores
    Capacidad
    Modificadores
    (C++17)
    (C++17)
    (C++17)
    (C++17)
    Búsqueda
    (C++20)
    Interfaz de depósito
    Política de dispersión
    Observadores
    Funciones no miembro
    (hasta C++20)
    (C++20)
    Guías de deducción(C++17)
     
    <tbody> </tbody>
    template< class... Args > pair<iterator, bool> try_emplace( const Key& k, Args&&... args );
    		 (1) (desde C++17)
    template< class... Args > pair<iterator, bool> try_emplace( Key&& k, Args&&... args );
    		 (2) (desde C++17)
    template< class... Args > iterator try_emplace( const_iterator hint, const Key& k, Args&&... args );
    		 (3) (desde C++17)
    template< class... Args > iterator try_emplace( const_iterator hint, Key&& k, Args&&... args );
    		 (4) (desde C++17)

    Inserta un nuevo elemento en el contenedor con la clave k y el valor construido con args, si no hay ningún elemento con tal clave en el contenedor.

    1) Si una clave equivalente a k ya existe en el contenedor, no hace nada. De lo contrario, 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) Si una clave equivalente a k ya existe en el contenedor, no hace nada. De lo contrario, 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) Si una clave equivalente a k ya existe en el contenedor, no hace nada. De lo contrario, 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)...))
    4) Si una clave equivalente a k ya existe en el contenedor, no hace nada. De lo contrario, 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)...))

    Si ocurre una redispersión (rehashing) debido a la inserción, se invalidan todos los iteradores. De lo contrario, no se afectan los iteradores. Las referencias no se invalidan. La dispersión vuelve a ocurrir solo si el nuevo número de elementos es mayor que max_load_factor()*bucket_count().

    Parámetros

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

    Valor de retorno

    1,2) Igual que para emplace
    3,4) Igual que para emplace_hint

    Complejidad

    1,2) Igual que para emplace
    3,4) Igual que para emplace_hint

    Notas

    A diferencia de insert o emplace, estas funciones no se mueven de los argumentos r-valor si la inserción no ocurre, lo que facilita la manipulación de mapas cuyos valores son tipos de solo movimiento, tales como std::unordered_map<std::string, std::unique_ptr<foo>>. Además, try_emplace trata la clave y los argumentos al tipo mapped_type de manera separada, a diferencia de emplace, que requiere que los argumentos construyan un value_type (es decir, un std::pair).

    Ejemplo

    Ejecuta este código
    #include <iostream>
#include <utility>
#include <string>

#include <unordered_map>

auto imprimir_nodo = [](const auto &nodo) {
    std::cout << "[" << nodo.first << "] = " << nodo.second << '\n';
};

auto imprimir_resultado = [](auto const &pair) {
    std::cout << (pair.second ? "insertado: " : "ignorado:  ");
    imprimir_nodo(*pair.first);
};

int main()
{
    using namespace std::literals;
    std::unordered_map<std::string, std::string> m;

    imprimir_resultado( m.try_emplace("a", "a"s) );
    imprimir_resultado( m.try_emplace("b", "abcd") );
    imprimir_resultado( m.try_emplace("c", 10, 'c') );
    imprimir_resultado( m.try_emplace("c", "No será insertado") );

    for (const auto &p : m) { imprimir_nodo(p); }
}

    Posible salida: 

    insertado: [a] = a
insertado: [b] = abcd
insertado: [c] = cccccccccc
ignorado:  [c] = cccccccccc
[a] = a
[b] = abcd
[c] = cccccccccc

    Véase también

    (C++11)
    		 Construye el elemento en el sitio.
    (función miembro pública) [editar]
    (C++11)
    		 Construye elementos en el sitio utilizando una pista.
    (función miembro pública) [editar]
    (C++11)
    		 Inserta elementos o nodos (desde C++17)
    (función miembro pública) [editar]