std::vector<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 benötigte Speicherort jedoch bereits von einem existierenden Element belegt ist, wird das einzufügende Element zunächst an einem anderen Ort konstruiert und dann durch Move-Zuweisung an den benötigten 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.

Falls nach der Operation die neue size() größer ist als die alte capacity() , findet eine Neuzuweisung statt, in welchem Fall alle Iteratoren (einschließlich des end() -Iterators) und alle Referenzen auf die Elemente ungültig werden. Andernfalls bleiben nur die Iteratoren und Referenzen vor der Einfügeposition gültig.

Parameter

Rückgabewert

Iterator, der auf das platzierte Element zeigt.

Komplexität

Linear in der Entfernung zwischen pos und end() .

Exceptions

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 am Ende ausgelöst wird und T entweder CopyInsertable oder nothrow move-konstruierbar ist, gibt es keine Auswirkungen (starke Ausnahmesicherheitsgarantie).

Andernfalls sind die Auswirkungen nicht spezifiziert.

Beispiel

#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';
}

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