Namespaces
Variants

std::forward_list<T,Allocator>:: insert_after

From cppreference.net
C++
Containers library
std::forward_list
Member functions
Non-member functions
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20)
Deduction guides (C++17)
iterator insert_after ( const_iterator pos, const T & value ) ;
(1) (seit C++11)
(constexpr seit C++26)
iterator insert_after ( const_iterator pos, T && value ) ;
(2) (seit C++11)
(constexpr seit C++26)
iterator insert_after ( const_iterator pos,
size_type count, const T & value ) ;
(3) (seit C++11)
(constexpr seit C++26)
template < class InputIt >

iterator insert_after ( const_iterator pos,

InputIt first, InputIt last ) ;
(4) (seit C++11)
(constexpr seit C++26)
iterator insert_after ( const_iterator pos,
std:: initializer_list < T > ilist ) ;
(5) (seit C++11)
(constexpr seit C++26)

Fügt Elemente nach der angegebenen Position im Container ein. Wenn pos gleich before_begin() ist, wird das erste eingefügte Element (falls vorhanden) zum ersten Element von * this .

Wenn pos nicht im Bereich [ before_begin() , end() ) liegt, ist das Verhalten undefiniert.

1,2) Fügt eine Kopie von value nach pos ein.
1) Wenn T nicht CopyInsertable in forward_list ist, ist das Verhalten undefiniert.
2) Wenn T nicht MoveInsertable in forward_list ist, ist das Verhalten undefiniert.
3) Fügt count Kopien des Werts nach pos ein.
Wenn T nicht CopyInsertable in forward_list ist, ist das Verhalten undefiniert.
4) Fügt Elemente aus dem Bereich [ first , last ) nach pos ein.
Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn InputIt die Anforderungen von LegacyInputIterator erfüllt.
Wenn eine der folgenden Bedingungen erfüllt ist, ist das Verhalten undefiniert:
5) Fügt Elemente aus der Initialisierungsliste ilist nach pos ein.
Entspricht return insert_after ( position, ilist. begin ( ) , ilist. end ( ) ) ; .

Keine Iteratoren oder Referenzen werden ungültig.

Inhaltsverzeichnis

Parameter

pos - Iterator nach dem der Inhalt eingefügt wird
value - Elementwert zum Einfügen
count - Anzahl der einzufügenden Kopien
first, last - Das Iteratorpaar, das den Quell- Bereich der einzufügenden Elemente definiert
ilist - Initialisierungsliste, aus der die Werte eingefügt werden

Rückgabewert

1,2) Iterator zum eingefügten Element.
3) Iterator zum zuletzt eingefügten Element, oder pos falls count == 0 zutrifft true .
4) Iterator zum zuletzt eingefügten Element, oder pos falls first == last true ist.
5) Iterator zum zuletzt eingefügten Element, oder pos falls ilist leer ist.

Ausnahmen

Wenn aus irgendeinem Grund eine Exception ausgelöst wird, haben diese Funktionen keine Wirkung ( strong exception safety guarantee ).

Komplexität

1,2) Konstant.
3) Linear in count .
4) Linear in std:: distance ( first, last ) .
5) Linear in ilist. size ( ) .

Beispiel

Diesen Code ausführen 
#include <forward_list>
#include <iostream>
#include <string>
#include <vector>
void print(const std::forward_list<int>& list)
{
    std::cout << "list: {";
    for (char comma[3] = {'\0', ' ', '\0'}; int i : list)
    {
        std::cout << comma << i;
        comma[0] = ',';
    }
    std::cout << "}\n";
}
int main()
{
    std::forward_list<int> ints{1, 2, 3, 4, 5};
    print(ints);
    // insert_after (2)
    auto beginIt = ints.begin();
    ints.insert_after(beginIt, -6);
    print(ints);
    // insert_after (3)
    auto anotherIt = beginIt;
    ++anotherIt;
    anotherIt = ints.insert_after(anotherIt, 2, -7);
    print(ints);
    // insert_after (4)
    const std::vector<int> v = {-8, -9, -10};
    anotherIt = ints.insert_after(anotherIt, v.cbegin(), v.cend());
    print(ints);
    // insert_after (5)
    ints.insert_after(anotherIt, {-11, -12, -13, -14});
    print(ints);
}

Ausgabe: 

list: {1, 2, 3, 4, 5}
list: {1, -6, 2, 3, 4, 5}
list: {1, -6, -7, -7, 2, 3, 4, 5}
list: {1, -6, -7, -7, -8, -9, -10, 2, 3, 4, 5}
list: {1, -6, -7, -7, -8, -9, -10, -11, -12, -13, -14, 2, 3, 4, 5}

Siehe auch

Konstruiert Elemente direkt nach einem Element
(öffentliche Elementfunktion)
Fügt ein Element am Anfang ein
(öffentliche Elementfunktion)