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

Inserta un nuevo elemento en el contenedor construido in-situ con los args dados, si no existe ningún elemento con la clave en el contenedor.

El constructor del nuevo elemento (es decir, std:: pair < const Key, T > ) se invoca exactamente con los mismos argumentos proporcionados a emplace , reenviados mediante std:: forward < Args > ( args ) ... . El elemento puede construirse incluso si ya existe un elemento con la misma clave en el contenedor, en cuyo caso el elemento recién construido se destruirá inmediatamente (consulte try_emplace() si este comportamiento no es deseable).

Si value_type no es EmplaceConstructible en unordered_map desde args , el comportamiento es indefinido.

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.

Parámetros

Valor de retorno

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.

Excepciones

Si se lanza una excepción por cualquier razón, esta función no tiene efecto ( strong exception safety guarantee ).

Complejidad

Constante amortizado en promedio, lineal en el peor caso según el tamaño del contenedor.

Notas

El uso cuidadoso de emplace permite construir el nuevo elemento evitando operaciones innecesarias de copia o movimiento.

Ejemplo

#include <iostream>
#include <string>
#include <utility>
#include <unordered_map>
int main()
{
    std::unordered_map<std::string, std::string> m;
    // utiliza el constructor de movimiento de pair
    m.emplace(std::make_pair(std::string("a"), std::string("a")));
    // utiliza el constructor de movimiento de conversión de pair
    m.emplace(std::make_pair("b", "abcd"));
    // utiliza el constructor de plantilla de pair
    m.emplace("d", "ddd");
    // emplace con clave duplicada no tiene efecto
    m.emplace("d", "DDD");
    // utiliza el constructor por partes de pair
    m.emplace(std::piecewise_construct,
              std::forward_as_tuple("c"),
              std::forward_as_tuple(10, 'c'));
    // una alternativa es: m.try_emplace("c", 10, 'c');
    for (const auto& p : m)
        std::cout << p.first << " => " << p.second << '\n';
}

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

Véase también