std::flat_map<Key,T,Compare,KeyContainer,MappedContainer>:: emplace

Fügt ein neues Element in den Container ein, das vor Ort mit den gegebenen args konstruiert wird, falls kein Element mit dem Schlüssel im Container vorhanden ist.

Initialisiert ein Objekt t vom Typ std:: pair < key_type, mapped_type > mit std:: forward < Args > ( args ) ... ; falls die Map bereits ein Element enthält, dessen Schlüssel äquivalent zu t. first ist, bleibt * this unverändert. Andernfalls äquivalent zu:

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));

Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn std:: is_constructible_v < std:: pair < key_type, mapped_type > , Args... > true ist.

Wenn value_type nicht EmplaceConstructible in flat_map aus args ist, ist das Verhalten undefiniert.

Parameter

Rückgabewert

Ein Paar bestehend aus einem Iterator zum eingefügten Element (oder zum Element, das die Einfügung verhindert hat) und einem bool -Wert, der auf true gesetzt ist, genau dann wenn die Einfügung stattgefunden hat.

Exceptions

Wenn aus irgendeinem Grund eine Exception ausgelöst wird, hat diese Funktion keine Wirkung ( strong exception safety guarantee ).

Komplexität

Wenn eine Einfügung stattfindet, linear in der Größe des Containers, andernfalls logarithmisch in der Größe des Containers

Hinweise

Sorgfältige Verwendung von emplace ermöglicht die Konstruktion des neuen Elements, während unnötige Kopier- oder Verschiebeoperationen vermieden werden.

Beispiel

#include <iostream>
#include <string>
#include <utility>
#include <flat_map>
int main()
{
    std::flat_map<std::string, std::string> m;
    // verwendet pair's Move-Konstruktor
    m.emplace(std::make_pair(std::string("a"), std::string("a")));
    // verwendet pair's konvertierenden Move-Konstruktor
    m.emplace(std::make_pair("b", "abcd"));
    // verwendet pair's Template-Konstruktor
    m.emplace("d", "ddd");
    // emplace mit doppeltem Schlüssel hat keine Wirkung
    m.emplace("d", "DDD");
    // verwendet pair's piecewise Konstruktor
    m.emplace(std::piecewise_construct,
              std::forward_as_tuple("c"),
              std::forward_as_tuple(10, 'c'));
    // eine Alternative ist: 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

Siehe auch