std::map<Key,T,Compare,Allocator>::emplace

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Container-Bibliothek

Sequenz

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

hive (C++26)

deque

forward_list (C++11)

list

Assoziativ

setzt

multiset

map

multimap

Ungeordnete assoziative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adapter

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Ansichten

span (C++20)

mdspan (C++23)

Tabellen

Iterator-Invalidierung

Mitgliedsfunktionstabelle

Nicht-Mitgliedsfunktionstabelle

 

std::map

Memberfunktionen

map::map map::~map               map::operator= map::get_allocator

Elementzugriff map::at map::operator[] Iteratoren map::beginmap::cbegin (C++11) map::endmap::cend (C++11) map::rbeginmap::crbegin (C++11)      map::rendmap::crend (C++11) Kapazität map::size map::max_size map::empty Observer map::key_comp map::value_comp Modifizierer map::clear map::insert map::erase map::swap map::extract (C++17) map::merge (C++17) map::insert_range (C++23) map::insert_or_assign (C++17) map::emplace (C++11) map::emplace_hint (C++11) map::try_emplace (C++17) Suche map::count map::find map::contains (C++20) map::equal_range map::lower_bound map::upper_bound

Nicht-Member-Funktionen

operator==operator<=> (C++20) std::swap(std::map) erase_if(std::map) (C++20)   operator!=operator<operator>operator<=operator>= (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)

Leitfaden zur Ableitung (C++17)

 

template< class... Args > std::pair<iterator, bool> emplace( Args&&... args );		(seit C++11)

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

Der Konstruktor des neuen Elements (d.h. std::pair<const Key, T>) wird mit exakt denselben Argumenten aufgerufen, die an emplace übergeben wurden, weitergeleitet mittels std::forward<Args>(args).... Das Element kann auch dann konstruiert werden, wenn bereits ein Element mit dem Schlüssel im Container vorhanden ist, in diesem Fall wird das neu konstruierte Element sofort zerstört (siehe try_emplace(), falls dieses Verhalten unerwünscht ist).

Eine sorgfältige Verwendung von emplace ermöglicht die Konstruktion des neuen Elements unter Vermeidung unnötiger Kopier- oder Verschiebungsoperationen.

Keine Iteratoren oder Referenzen werden ungültig.

Parameter

args

-

Argumente, die an den Konstruktor des Elements weitergeleitet werden

Rückgabewert

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

Ausnahmen

Wenn aus irgendeinem Grund eine Ausnahme ausgelöst wird, hat diese Funktion keine Auswirkungen (starkes Ausnahmesicherheitsgarantie).

Komplexität

Logarithmisch zur Größe des Containers.

Beispiel

Führen Sie diesen Code aus

#include <iostream>
#include <string>
#include <utility>
#include <map>
 
int main()
{
    std::map<std::string, std::string> m;
 
    // uses pair's move constructor
    m.emplace(std::make_pair(std::string("a"), std::string("a")));
 
    // uses pair's converting move constructor
    m.emplace(std::make_pair("b", "abcd"));
 
    // uses pair's template constructor
    m.emplace("d", "ddd");
 
    // emplace with duplicate key has no effect
    m.emplace("d", "DDD");
 
    // uses pair's piecewise constructor
    m.emplace(std::piecewise_construct,
              std::forward_as_tuple("c"),
              std::forward_as_tuple(10, 'c'));
    // an alternative is: m.try_emplace("c", 10, 'c');
 
    for (const auto& p : m)
        std::cout << p.first << " => " << p.second << '\n';
}

Ausgabe

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

Siehe auch

emplace_hint (C++11)	konstruiert Elemente "in place" unter Verwendung eines Hinweises (public member function)
try_emplace (C++17)	fügt "in place" ein, wenn der Schlüssel nicht existiert, tut nichts, wenn der Schlüssel existiert (public member function)
insert	fügt Elemente ein oder Knoten(seit C++17) (public member function)