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

Inserta un nuevo elemento en el contenedor construido in-situ con los args dados.

El constructor del nuevo elemento (es decir, std:: pair < const Key, T > ) se invoca exactamente con los mismos argumentos suministrados a emplace , reenviados mediante std:: forward < Args > ( args ) ... .

Si value_type no es EmplaceConstructible en unordered_multimap 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() ocurre una redistribución (rehashing).
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 iterador al elemento insertado.

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_multimap<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
    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'));
    for (const auto& p : m)
        std::cout << p.first << " => " << p.second << '\n';
}

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

Véase también