Namespaces
Variants

std::forward_list<T,Allocator>:: splice_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)
void splice_after ( forward_list & other ) ;
(1) (seit C++11)
(constexpr seit C++26)
void splice_after ( forward_list && other ) ;
(2) (seit C++11)
(constexpr seit C++26)
void splice_after ( forward_list & other,
const_iterator it ) ;
(3) (seit C++11)
(constexpr seit C++26)
void splice_after ( forward_list && other,
const_iterator it ) ;
(4) (seit C++11)
(constexpr seit C++26)
void splice_after ( forward_list & other,
const_iterator first, const_iterator last ) ;
(5) (seit C++11)
(constexpr seit C++26)
void splice_after ( forward_list && other,
const_iterator first, const_iterator last ) ;
(6) (seit C++11)
(constexpr seit C++26)

Überträgt Elemente von other zu * this . Die Elemente werden nach pos eingefügt.

Wenn eine der folgenden Bedingungen erfüllt ist, ist das Verhalten undefiniert:

  • pos liegt nicht im Bereich ( before_begin() , end() ) .
  • get_allocator ( ) == other. get_allocator ( ) ist false .
1,2) Überträgt alle Elemente von other . other wird nach dem Vorgang leer.
Wenn * this und other auf dasselbe Objekt verweisen, ist das Verhalten undefiniert.
3,4) Überträgt das Element nach it .
* this und other können auf dasselbe Objekt verweisen. In diesem Fall gibt es keine Auswirkung, wenn pos == it oder pos == ++ it true ist.
Wenn ++ it nicht im Bereich [ begin ( ) , end ( ) ) liegt, ist das Verhalten undefiniert.
5,6) Überträgt Elemente im Bereich ( first , last ) .
* this und other können auf dasselbe Objekt verweisen.
Wenn eine der folgenden Bedingungen erfüllt ist, ist das Verhalten undefiniert:
  • ( first , last ) ist kein gültiger Bereich in other ,
  • Ein Iterator in ( first , last ) ist nicht dereferenzierbar.
  • pos liegt in ( first , last ) .

Keine Iteratoren oder Referenzen werden ungültig. Wenn * this und other auf verschiedene Objekte verweisen, beziehen sich die Iteratoren zu den übertragenen Elementen nun auf * this , nicht auf other .

Inhaltsverzeichnis

Parameter

pos - Position nach der der Inhalt eingefügt wird
other - Anderer Container, aus dem der Inhalt übertragen wird
it - Iterator vor dem Iterator zum Element, das von other nach * this übertragen wird
first, last - Iteratorpaar, das den Bereich der Elemente definiert, die von other nach * this übertragen werden

Exceptions

1-4) Wirft nichts.

Komplexität

1,2) Linear in der Größe von other .
3,4) Konstante.
5,6) Linear in std:: distance ( first, last ) .

Beispiel

Diesen Code ausführen 
#include <cassert>
#include <forward_list>
int main()
{
    using F = std::forward_list<int>;
    // Demonstriert die Bedeutung des offenen Bereichs (first, last)
    // in Überladung (5): Das erste Element von l1 wird nicht übertragen.
    F l1 = {1, 2, 3, 4, 5};
    F l2 = {10, 11, 12};
    l2.splice_after(l2.cbegin(), l1, l1.cbegin(), l1.cend());
    // Nicht äquivalent zu l2.splice_after(l2.cbegin(), l1);
    // was äquivalent ist zu
    // l2.splice_after(l2.cbegin(), l1, l1.cbefore_begin(), l1.end());
    assert((l1 == F{1}));
    assert((l2 == F{10, 2, 3, 4, 5, 11, 12}));
    // Überladung (1)
    F x = {1, 2, 3, 4, 5};
    F y = {10, 11, 12};
    x.splice_after(x.cbegin(), y);
    assert((x == F{1, 10, 11, 12, 2, 3, 4, 5}));
    assert((y == F{}));
    // Überladung (3)
    x = {1, 2, 3, 4, 5};
    y = {10, 11, 12};
    x.splice_after(x.cbegin(), y, y.cbegin());
    assert((x == F{1, 11, 2, 3, 4, 5}));
    assert((y == F{10, 12}));
    // Überladung (5)
    x = {1, 2, 3, 4, 5};
    y = {10, 11, 12};
    x.splice_after(x.cbegin(), y, y.cbegin(), y.cend());
    assert((x == F{1, 11, 12, 2, 3, 4, 5}));
    assert((y == F{10}));
}

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 2045 C++11 O(1)-Spleißen konnte nicht garantiert werden, wenn
get_allocator ( ) ! = other. get_allocator ( ) 		das Verhalten ist
in diesem Fall undefiniert
LWG 2222 C++11 das von it referenzierte Element wird nicht übertragen, aber Zeiger, Referenzen und
Iteratoren, die darauf verweisen, würden nach dem Spleißen auf ein Element in * this verweisen 		verweisen weiterhin auf das
Element in other

Siehe auch

vereinigt zwei sortierte Listen
(öffentliche Elementfunktion)
entfernt Elemente nach bestimmten Kriterien
(öffentliche Elementfunktion)
gibt einen Iterator auf das Element vor dem Anfang zurück
(öffentliche Elementfunktion)