Namespaces
Variants

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

From cppreference.net

C++
Containers library
std::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 ( const_iterator pos, const T & value ) ;
(1) (constexpr seit C++26)
iterator insert ( const_iterator pos, T && value ) ;
(2) (seit C++11)
(constexpr seit C++26)
iterator insert ( const_iterator pos,
size_type count, const T & value ) ;
(3) (constexpr seit C++26)
template < class InputIt >
iterator insert ( const_iterator pos, InputIt first, InputIt last ) ;
(4) (constexpr seit C++26)
iterator insert ( const_iterator pos, std:: initializer_list < T > ilist ) ;
(5) (seit C++11)
(constexpr seit C++26)

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

1) Fügt eine Kopie von value vor pos ein.

Falls T nicht CopyInsertable in list ist, ist das Verhalten undefiniert.

(seit C++11)
2) Fügt value vor pos ein, möglicherweise unter Verwendung von Move-Semantik.
Wenn T nicht MoveInsertable in list ist, ist das Verhalten undefiniert.
3) Fügt count Kopien des Werts value vor pos ein.
Wenn eine der folgenden Bedingungen erfüllt ist, ist das Verhalten undefiniert:
(seit C++11)
4) Fügt Elemente aus dem Bereich [ first , last ) vor pos ein.

Diese Überladung hat denselben Effekt wie Überladung (3) , wenn InputIt ein integraler Typ ist.

(bis C++11)

Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn InputIt die Anforderungen von LegacyInputIterator erfüllt.

(seit C++11)
Wenn eine der folgenden Bedingungen erfüllt ist, ist das Verhalten undefiniert:
(seit C++11)
  • first oder last sind Iteratoren in * this .
5) Fügt Elemente aus der Initialisierungsliste ilist vor pos ein.
Entspricht insert ( pos, ilist. begin ( ) , ilist. end ( ) ) .


Keine Iteratoren oder Referenzen werden ungültig.

Inhaltsverzeichnis

Parameter

pos - Iterator vor dem der Inhalt eingefügt wird
value - Einzufügender Elementwert
count - Anzahl der einzufügenden Elemente
first, last - Das Iteratorpaar, das den Bereich der einzufügenden Elemente definiert
ilist - std::initializer_list zum Einfügen der Werte

Rückgabewert

1,2) Iterator, der auf den eingefügten value zeigt.
3-5) Iterator, der auf das erste eingefügte Element zeigt, oder pos falls kein Element eingefügt wurde.

Komplexität

Linear in der Anzahl der eingefügten Elemente.

Ausnahmen

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

Beispiel

Diesen Code ausführen 
#include <iostream>
#include <iterator>
#include <string_view>
#include <list>
namespace stq
{
    void println(std::string_view rem, const std::list<int>& container)
    {
        std::cout << rem.substr(0, rem.size() - 2) << '[';
        bool first{true};
        for (const int x : container)
            std::cout << (first ? first = false, "" : ", ") << x;
        std::cout << "]\n";
    }
}
int main()
{
    std::list<int> c1(3, 100);
    stq::println("1. {}", c1);
    auto pos = c1.begin();
    pos = c1.insert(pos, 200); // Überladung (1)
    stq::println("2. {}", c1);
    c1.insert(pos, 2, 300); // Überladung (3)
    stq::println("3. {}", c1);
    // pos auf begin zurücksetzen:
    pos = c1.begin();
    std::list<int> c2(2, 400);
    c1.insert(std::next(pos, 2), c2.begin(), c2.end()); // Überladung (4)
    stq::println("4. {}", c1);
    int arr[] = {501, 502, 503};
    c1.insert(c1.begin(), arr, arr + std::size(arr)); // Überladung (4)
    stq::println("5. {}", c1);
    c1.insert(c1.end(), {601, 602, 603}); // Überladung (5)
    stq::println("6. {}", c1);
}

Ausgabe: 

1. [100, 100, 100]
2. [200, 100, 100, 100]
3. [300, 300, 200, 100, 100, 100]
4. [300, 300, 400, 400, 200, 100, 100, 100]
5. [501, 502, 503, 300, 300, 400, 400, 200, 100, 100, 100]
6. [501, 502, 503, 300, 300, 400, 400, 200, 100, 100, 100, 601, 602, 603]

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 149 C++98 Überladungen ( 3 ) und ( 4 ) gaben nichts zurück gibt einen Iterator zurück

Siehe auch

(C++11)
Konstruiert Element direkt an Ort und Stelle
(öffentliche Elementfunktion)
Fügt ein Element am Anfang ein
(öffentliche Elementfunktion)
Fügt ein Element am Ende hinzu
(öffentliche Elementfunktion)
Erstellt einen std::insert_iterator vom aus dem Argument abgeleiteten Typ
(Funktionstemplate)