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

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Container-Bibliothek

Sequenz

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

hive (C++26)

deque

forward_list (C++11)

list

Assoziativ

setzt

multiset

map

multimap

Ungeordnete assoziative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adapter

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Ansichten

span (C++20)

mdspan (C++23)

Tabellen

Iterator-Invalidierung

Mitgliedsfunktionstabelle

Nicht-Mitgliedsfunktionstabelle

 

std::forward_list

Memberfunktionen
forward_list::forward_list forward_list::~forward_list forward_list::operator= forward_list::assign forward_list::assign_range (C++23)   forward_list::get_allocator Elementzugriff forward_list::front Iteratoren forward_list::before_beginforward_list::cbefore_begin forward_list::beginforward_list::cbegin forward_list::endforward_list::cend Kapazität forward_list::empty forward_list::max_size	Modifizierer forward_list::clear forward_list::emplace_front forward_list::push_front forward_list::insert_after forward_list::emplace_after forward_list::erase_after forward_list::insert_range_after (C++23) forward_list::prepend_range (C++23) forward_list::pop_front forward_list::resize forward_list::swap Operationen forward_list::merge forward_list::splice_after forward_list::removeforward_list::remove_if forward_list::reverse forward_list::unique forward_list::sort
Nicht-Member-Funktionen
operator==operator<=> (C++20) swap(std::forward_list) erase(std::forward_list)erase_if(std::forward_list) (C++20)(C++20)	operator!=operator<operator>operator<=operator>= (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)
Deduction guides (C++17)

 

void splice_after( const_iterator pos, forward_list& other );	(1)	(seit C++11)
void splice_after( const_iterator pos, forward_list&& other );	(2)	(seit C++11)
void splice_after( const_iterator pos, forward_list& other,                    const_iterator it );	(3)	(seit C++11)
void splice_after( const_iterator pos, forward_list&& other,                    const_iterator it );	(4)	(seit C++11)
void splice_after( const_iterator pos, forward_list& other,                    const_iterator first, const_iterator last );	(5)	(seit C++11)
void splice_after( const_iterator pos, forward_list&& other,                    const_iterator first, const_iterator last );	(6)	(seit C++11)

Verschiebt Elemente aus einer anderen forward_list nach *this. Die Elemente werden nach dem von pos bezeichneten Element eingefügt.

Es werden keine Elemente kopiert. Keine Iteratoren oder Referenzen werden ungültig. Die Iteratoren zu den verschobenen Elementen verweisen nun auf *this, nicht auf other.

1,2) Verschiebt alle Elemente von other nach *this. Der Container other wird nach der Operation leer.

3,4) Verschiebt das Element, das auf den Iterator nach it folgt, von other nach *this. Hat keine Auswirkung, wenn pos == it oder wenn pos == ++it.

5,6) Verschiebt die Elemente im Bereich (first, last) von other nach *this. Das von first bezeichnete Element wird nicht verschoben.

Das Verhalten ist undefiniert, wenn

• get_allocator() != other.get_allocator(),
• pos ist weder before_begin() noch ein dereferenzierbarer Iterator im Bereich [begin(), end()),
• für Überladungen (1,2), *this und other bezeichnen dasselbe Objekt,
• für Überladungen (3,4), ist der Iterator nach it kein dereferenzierbarer Iterator in other, oder
• für Überladungen (5,6),

• (first, last) ist kein gültiger Bereich in other,
• einige Iteratoren in (first, last) sind nicht dereferenzierbar, oder
• pos befindet sich in (first, last).

Parameter

pos	-	Element, nach dem der Inhalt eingefügt werden soll
Sonstiges	-	Ein anderer Container, aus dem der Inhalt verschoben werden soll
it	-	Iterator, der dem zu verschiebenden Element aus other nach *this vorangeht
first, last	-	Das Paar von Iteratoren, das den Bereich der zu verschiebenden Elemente aus other nach *this definiert

Ausnahmen

Wirft nichts.

Komplexität

1,2) Linear bezüglich der Größe von other.

3,4) Konstant.

5,6) Linear bezüglich std::distance(first, last).

Beispiel

Führen Sie diesen Code aus

#include <cassert>
#include <forward_list>
 
int main()
{
    using F = std::forward_list<int>;
 
    // Demonstrate the meaning of open range (first, last)
    // in overload (5): the first element of l1 is not moved.
    F l1 = {1, 2, 3, 4, 5};
    F l2 = {10, 11, 12};
 
    l2.splice_after(l2.cbegin(), l1, l1.cbegin(), l1.cend());
    // Not equivalent to l2.splice_after(l2.cbegin(), l1);
    // which is equivalent to
    // 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}));
 
    // Overload (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{}));
 
    // Overload (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}));
 
    // Overload (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	Korrigiertes Verhalten
LWG 2045	C++11	O(1) Splicing konnte nicht garantiert werden, wenn get_allocator() != other.get_allocator()	Das Verhalten ist in diesem Fall nicht definiert.
LWG 2222	C++11	das von it bezeichnete Element nicht verschoben wird, aber Zeiger, Referenzen und Iteratoren, die sich darauf beziehen, nach dem Splicing auf ein Element in *this verweisen würden	sich weiterhin auf das Element in other

Siehe auch

merge	fügt zwei sortierte Listen zusammen (public member function)
removeremove_if	entfernt Elemente, die bestimmte Kriterien erfüllen (public member function)
before_begincbefore_begin	gibt einen Iterator vor dem Anfang zurück (public member function)