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

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

Das Element wird durch std::allocator_traits::construct konstruiert, welches Placement- new verwendet, um das Element direkt an einem vom Container bereitgestellten Speicherort zu konstruieren.

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.

Keine Iteratoren oder Referenzen werden ungültig.

Parameter

Rückgabewert

Iterator, der auf das eingefügte Element zeigt.

Komplexität

Konstante.

Ausnahmen

Wenn eine Exception ausgelöst wird (z.B. durch den Konstruktor), bleibt der Container unverändert, als ob diese Funktion niemals aufgerufen worden wäre (starke Exception-Garantie).

Beispiel

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

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