Namespaces
Variants

    std::inplace_vector<T,N>::insert

    Von de.cppreference.net
     
    C++
     
    Container-Bibliothek
     
    std::inplace_vector
    Membertypen
    Memberfunktionen
    Nicht-Memberfunktionen
     
    constexpr iterator insert( const_iterator pos, const T& value );
    		(1) (since C++26) 
    constexpr iterator insert( const_iterator pos, T&& value );
    		(2) (since C++26) 
    constexpr iterator insert( const_iterator pos, size_type count, const T& value );
    		(3) (since C++26) 
    template< class InputIt >
constexpr iterator insert( const_iterator pos, InputIt first, InputIt last );
    		(4) (since C++26) 
    constexpr iterator insert( const_iterator pos, std::initializer_list<T> ilist );
    		(5) (since C++26)

    Fügt Elemente an der angegebenen Position im Container ein.

    1) Fügt eine Kopie von value vor pos.
    2) Fügt value vor pos, möglicherweise unter Verwendung von Move-Semantik.
    3) Fügt count Kopien des value vor pos.
    4) Fügt Elemente aus dem Bereich [first, last) vor pos. Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn InputIt ein LegacyInputIterator ist (um Mehrdeutigkeit mit der Überladung (3)).
    Jeder Iterator in [first, last) wird einmal dereferenziert.
    Wenn first und last Iteratoren in *this sind, ist das Verhalten undefiniert.
    5) Fügt Elemente aus der Initialisierungsliste ilist vor pos. Entspricht: insert(pos, ilist.begin(), ilist.end());.
    Dieser Abschnitt ist unvollständig

    Parameter

    pos - Iterator vor dem der Inhalt eingefügt wird ( pos kann der end() Iterator sein)
    value - Einzufügender Elementwert
    count - Anzahl der einzufügenden Elemente
    first, last - Das Iteratorpaar, das den Quell- Bereich der einzufügenden Elemente definiert
    ilist - std::initializer_list von der die Werte eingefügt werden
    Typanforderungen
    -
    T muss die Anforderungen von CopyInsertable erfüllen, um Überladung (1) zu verwenden.
    -
    T muss die Anforderungen von MoveInsertable erfüllen, um Überladung (2) zu verwenden.
    -
    T muss die Anforderungen von CopyAssignable und CopyInsertable erfüllen, um Überladung (3) zu verwenden.
    -
    T muss die Anforderungen von EmplaceConstructible erfüllen, um Überladungen (4,5) zu verwenden.

    Rückgabewert

    1,2) Iterator, der auf den eingefügten value zeigt.
    3) Iterator, der auf das erste eingefügte Element zeigt, oder pos falls count == 0 .
    4) Iterator, der auf das erste eingefügte Element zeigt, oder pos falls first == last .
    5) Iterator, der auf das erste eingefügte Element zeigt, oder pos falls ilist leer ist.

    Komplexität

    Linear in der Anzahl der eingefügten Elemente plus der Distanz zwischen pos und end() des Containers.

    Ausnahmen

    Beispiel

    Diesen Code ausführen 
    #include <initializer_list>
#include <inplace_vector>
#include <iterator>
#include <new>
#include <print>
int main()
{
    std::inplace_vector<int, 14> v(3, 100);
    std::println("1. {}", v);
    auto pos = v.begin();
    pos = v.insert(pos, 200); // Überladung (1)
    std::println("2. {}", v);
    v.insert(pos, 2, 300); // Überladung (3)
    std::println("3. {}", v);
    int arr[] = {501, 502, 503};
    v.insert(v.begin(), arr, arr + std::size(arr)); // Überladung (4)
    std::println("4. {}", v);
    v.insert(v.end(), {601, 602, 603}); // Überladung (5)
    std::println("5. {}", v);
    const auto list = {-13, -12, -11};
    try
    {
        v.insert(v.begin(), list); // wirft Exception: kein Speicherplatz
    }
    catch(const std::bad_alloc&)
    {
        std::println("bad_alloc: v.capacity()={} < v.size()={} + list.size()={}",
                     v.capacity(), v.size(), list.size());
    }
}

    Ausgabe: 

    1. [100, 100, 100]
2. [200, 100, 100, 100]
3. [300, 300, 200, 100, 100, 100]
4. [501, 502, 503, 300, 300, 200, 100, 100, 100]
5. [501, 502, 503, 300, 300, 200, 100, 100, 100, 601, 602, 603]
bad_alloc: v.capacity()=14 < v.size()=12 + list.size()=3

    Siehe auch

    		Konstruiert Element direkt vor Ort
    (öffentliche Elementfunktion)
    		Fügt einen Bereich von Elementen ein
    (öffentliche Elementfunktion)