std::list<T,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::list

Memberfunktionen
list::list list::~list list::operator= list::assign list::assign_range (C++23)   list::get_allocator Elementzugriff list::front list::back Iteratoren list::beginlist::cbegin (C++11) list::endlist::cend (C++11) list::rbeginlist::crbegin (C++11) list::rendlist::crend (C++11) Kapazität list::size list::empty list::max_size	Modifizierer list::clear list::insert list::insert_range (C++23) list::emplace (C++11) list::erase list::push_front list::emplace_front (C++11) list::prepend_range (C++23) list::pop_front list::push_back list::emplace_back (C++11) list::append_range (C++23) list::pop_back list::resize list::swap Operationen list::merge list::splice list::removelist::remove_if list::reverse list::unique list::sort
Nicht-Member-Funktionen
operator==operator<=> (C++20) swap(std::list) erase(std::list)erase_if(std::list) (C++20)(C++20)	operator!=operator<operator>operator<=operator>= (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)
Deduktionshilfen(C++17)

 

template< class... Args > iterator emplace( const_iterator pos, Args&&... args );		(seit C++11)

Fügt ein neues Element direkt vor pos in den Container ein.

Das Element wird durch std::allocator_traits::construct konstruiert, welche Placement new verwendet, um das Element an einer vom Container bereitgestellten Stelle zu konstruieren.

Die Argumente args... werden als std::forward<Args>(args)... an den Konstruktor weitergeleitet. args... dürfen direkt oder indirekt auf einen Wert im Container verweisen.

Keine Iteratoren oder Referenzen werden ungültig.

Parameter

pos	-	Iterator, vor dem das neue Element konstruiert wird
args	-	Argumente, die an den Konstruktor des Elements weitergeleitet werden
Typanforderungen
- T muss die Anforderungen von EmplaceConstructible erfüllen.

Rückgabewert

Iterator, der auf das eingefügte Element zeigt.

Komplexität

Konstant.

Ausnahmen

Wenn eine Ausnahme ausgelöst wird (z.B. vom Konstruktor), bleibt der Container unverändert, als ob diese Funktion nie aufgerufen worden wäre (starke Ausnahmegarantie).

Beispiel

Führen Sie diesen Code aus

#include <iostream>
#include <string>
#include <list>
 
struct A
{
    std::string s;
 
    A(std::string str) : s(std::move(str)) { std::cout << " constructed\n"; }
 
    A(const A& o) : s(o.s) { std::cout << " copy constructed\n"; }
 
    A(A&& o) : s(std::move(o.s)) { std::cout << " move constructed\n"; }
 
    A& operator=(const A& other)
    {
        s = other.s;
        std::cout << " copy assigned\n";
        return *this;
    }
 
    A& operator=(A&& other)
    {
        s = std::move(other.s);
        std::cout << " move assigned\n";
        return *this;
    }
};
 
int main()
{
    std::list<A> container;
 
    std::cout << "construct 2 times A:\n";
    A two{"two"};
    A three{"three"};
 
    std::cout << "emplace:\n";
    container.emplace(container.end(), "one");
 
    std::cout << "emplace with A&:\n";
    container.emplace(container.end(), two);
 
    std::cout << "emplace with A&&:\n";
    container.emplace(container.end(), std::move(three));
 
    std::cout << "content:\n";
    for (const auto& obj : container)
        std::cout << ' ' << obj.s;
    std::cout << '\n';
}

Ausgabe

construct 2 times A:
 constructed
 constructed
emplace:
 constructed
emplace with A&:
 copy constructed
emplace with A&&:
 move constructed
content:
 one two three

Fehlerberichte

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
LWG 2164	C++11	war unklar, ob die Argumente auf den Container verweisen können	wurde klargestellt

Siehe auch

insert	fügt Elemente ein (public member function)
emplace_back (C++11)	konstruiert ein Element direkt (in-place) am Ende (public member function)