std::vector<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::vector

Membertypen
Memberfunktionen
vector::vector vector::~vector vector::operator= vector::assign vector::assign_range (C++23)   vector::get_allocator Elementzugriff vector::operator[] vector::at vector::data vector::front vector::back Iteratoren vector::beginvector::cbegin (C++11) vector::endvector::cend (C++11) vector::rbeginvector::crbegin (C++11) vector::rendvector::crend (C++11)	Kapazität vector::empty vector::size vector::max_size vector::reserve vector::capacity vector::shrink_to_fit (DR*) Modifizierer vector::clear vector::erase vector::insert vector::insert_range (C++23) vector::append_range (C++23) vector::emplace (C++11) vector::emplace_back (C++11) vector::push_back vector::pop_back vector::resize vector::swap
Nicht-Member-Funktionen
operator==operator<=> (C++20) swap(std::vector) erase(std::vector)erase_if(std::vector) (C++20)(C++20)	operator!=operator<operator>operator<=operator>= (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)
Deduction guides(C++17)

 

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

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

Das Element wird über std::allocator_traits::construct konstruiert, was typischerweise Placement-new verwendet, um das Element an einer vom Container bereitgestellten Stelle direkt zu konstruieren. Wenn die benötigte Stelle jedoch bereits von einem vorhandenen Element belegt ist, wird das eingefügte Element zunächst an einer anderen Stelle konstruiert und dann an die benötigte Stelle verschoben.

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.

Wenn nach der Operation die neue size() größer ist als die alte capacity(), findet eine Reallokation statt, in diesem Fall werden alle Iteratoren (einschließlich des end() Iterators) und alle Referenzen auf die Elemente ungültig. Andernfalls bleiben nur die Iteratoren und Referenzen vor dem Einfügepunkt gü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 MoveAssignable, MoveInsertable und EmplaceConstructible erfüllen.

Rückgabewert

Iterator, der auf das eingefügte Element zeigt.

Komplexität

Linear zur Distanz zwischen pos und end().

Ausnahmen

Wenn eine Ausnahme geworfen wird, die nicht vom Kopierkonstruktor, dem Move-Konstruktor, dem Zuweisungsoperator oder dem Move-Zuweisungsoperator von T stammt, oder wenn eine Ausnahme geworfen wird, während emplace verwendet wird, um ein einzelnes Element am Ende einzufügen, und T entweder CopyInsertable oder nicht-ausnahmenbehaftet verschiebbar konstruierbar ist, hat dies keine Auswirkungen (starke Ausnahmegarantie).

Andernfalls sind die Auswirkungen undefiniert.

Beispiel

Führen Sie diesen Code aus

#include <iostream>
#include <string>
#include <vector>
 
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::vector<A> container;
    // reserve enough place so vector does not have to resize
    container.reserve(10);
    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)