std::deque<T,Allocator>:: emplace

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

Das Element wird durch std::allocator_traits::construct konstruiert, was typischerweise Placement- new verwendet, um das Element direkt an einem vom Container bereitgestellten Speicherort zu konstruieren. Falls der erforderliche Speicherort jedoch bereits von einem bestehenden Element belegt ist, wird das einzufügende Element zunächst an einem anderen Ort konstruiert und dann durch Move-Zuweisung an den erforderlichen Speicherort übertragen.

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

Alle Iteratoren (einschließlich des end() Iterators) werden ungültig. Referenzen werden ebenfalls ungültig, es sei denn pos == begin() oder pos == end() , in welchem Fall sie nicht ungültig werden.

Parameter

Rückgabewert

Iterator, der auf das eingefügte Element zeigt.

Komplexität

Linear in der geringeren der Entfernungen zwischen pos und einem der Enden des Containers.

Ausnahmen

Wenn eine Ausnahme ausgelöst wird, außer durch den Kopierkonstruktor, Move-Konstruktor, Zuweisungsoperator oder Move-Zuweisungsoperator von T , oder wenn eine Ausnahme während der Verwendung von emplace zum Einfügen eines einzelnen Elements an einem der beiden Enden ausgelöst wird, gibt es keine Auswirkungen (starke Ausnahmesicherheitsgarantie).

Andernfalls sind die Auswirkungen nicht spezifiziert.

Beispiel

#include <iostream>
#include <string>
#include <deque>
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::deque<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';
}

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.

Siehe auch