std::flat_map<Key,T,Compare,KeyContainer,MappedContainer>:: 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.

Inicializa un objeto t de tipo std:: pair < key_type, mapped_type > con std:: forward < Args > ( args ) ... ; si el mapa ya contiene un elemento cuya clave es equivalente a t. first , * this permanece sin cambios. De lo contrario, equivalente a:

auto key_it = ranges::upper_bound(c.keys, t.first, compare);
auto value_it = c.values.begin() + std::distance(c.keys.begin(), key_it);
c.keys.insert(key_it, std::move(t.first));
c.values.insert(value_it, std::move(t.second));

Esta sobrecarga participa en la resolución de sobrecarga solo si std:: is_constructible_v < std:: pair < key_type, mapped_type > , Args... > es true .

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

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

Si ocurre una inserción, lineal en el tamaño del contenedor, de lo contrario 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 <flat_map>
int main()
{
    std::flat_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