std::map<Key,T,Compare,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 map desde args , el comportamiento es indefinido.

No se invalidan iteradores ni referencias.

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

Logarítmico en 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 <map>
int main()
{
    std::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