forward_list-Klasse

Beschreibt ein Objekt, das eine Elementsequenz variabler Länge steuert. Die Sequenz wird als einfach verknüpfte Knotenliste gespeichert, die jeweils einen Member vom Typ Type enthält.

Syntax

template <class Type,
    class Allocator = allocator<Type>>
class forward_list

Parameter

Type
Der in forward_list zu speichernde Elementdatentyp.

Allocator
Das gespeicherte Allocatorobjekt, das Details zur forward_list Zuordnung und Zuordnung des Speichers kapselt. Dieser Parameter ist optional. Der Standardwert ist "allocator<Type>".

Hinweise

Ein forward_list Objekt reserviert und freigibt Speicher für die Sequenz, die es steuert, über ein gespeichertes Objekt der Klasse, das auf Allocatorallocator basiert (allgemein bekannt als ). Weitere Informationen finden Sie unter Allocators. Ein Allocator-Objekt muss dieselbe externe Schnittstelle wie ein Objekt vom Typ allocatoraufweisen.

Iteratoren, Zeiger und Verweise werden möglicherweise ungültig, wenn Elemente ihrer gesteuerten Sequenz von forward_list gelöscht werden. Einfügungen und Komplizen, die für die kontrollierte Sequenz forward_list ausgeführt werden, werden durch iteratoren nicht ungültig.

Ergänzungen zur kontrollierten Sequenz können durch Aufrufe forward_list::insert_aftererfolgen, bei denen es sich um die einzige Memberfunktion handelt, die den Konstruktor Type(const T&)aufruft. forward_list ruft möglicherweise auch Verschiebekonstruktoren auf. Wenn ein solcher Ausdruck eine Ausnahme auslöst, werden vom Containerobjekt keine neuen Elemente eingefügt, und die Ausnahme wird erneut ausgelöst. Daher verbleibt ein Objekt vom Typ forward_list in einem bekannten Zustand, wenn solche Ausnahmen auftreten.

Member

Konstruktoren

TypeDefs

Funktionen

Operatoren

allocator_type

Ein Typ, mit dem die Zuweisungsklasse für ein forward list-Objekt dargestellt wird.

typedef Allocator allocator_type;

Hinweise

allocator_type ist ein Synonym für den Vorlagenparameter Allocator.

assign

Löscht Elemente aus einer Vorwärtsliste und kopiert einen neuen Satz von Elementen an eine Zielvorwärtsliste.

void assign(
    size_type Count,
    const Type& Val);

void assign(
    initializer_list<Type> IList);

template <class InputIterator>
void assign(InputIterator First, InputIterator Last);

Parameter

first
Der Anfang des Ersetzungsbereichs.

last
Das Ende des Ersetzungsbereichs.

count
Die Anzahl zuzuweisender Elemente.

val
Der jedem Element zuzuweisende Wert.

Type
Der Typ des Werts.

IList
Der initializer_list zu kopierende Code.

Hinweise

Wenn es sich um forward_list einen ganzzahligen Typ handelt, verhält sich die erste Memberfunktion wie assign((size_type)First, (Type)Last). Andernfalls ersetzt die Memberfunktion die von *this gesteuerte Sequenz durch die Sequenz [ First, Last), die sich nicht mit der ursprünglichen gesteuerten Sequenz überschneiden darf.

Die zweite Memberfunktion ersetzt die Sequenz, die von *this durch eine Wiederholung von Count-Elementen des Werts Val gesteuert wird.

Die dritte Memberfunktion kopiert die Elemente des initializer_list Elements in die forward_list.

before_begin

Gibt einen Iterator zurück, der die Position vor dem ersten Element in einer Vorwärtsliste adressiert.

const_iterator before_begin() const;
iterator before_begin();

Rückgabewert

Gibt einen Forward-Iterator zurück, der unmittelbar vor das erste Element der Sequenz zeigt (bzw. unmittelbar vor das Ende einer leeren Sequenz)

begin

Gibt einen Iterator zurück, der das erste Element in einer Vorwärtsliste adressiert.

const_iterator begin() const;
iterator begin();

Rückgabewert

Ein Forward-Iterator, der auf das erste Element der Sequenz zeigt (bzw. unmittelbar hinter das Ende einer leeren Sequenz).

cbefore_begin

Gibt einen konstanten Iterator zurück, der die Position vor dem ersten Element in einer Vorwärtsliste adressiert.

const_iterator cbefore_begin() const;

Rückgabewert

Gibt einen Forward-Iterator zurück, der unmittelbar vor das erste Element der Sequenz zeigt (bzw. unmittelbar vor das Ende einer leeren Sequenz)

cbegin

Gibt einen const-Iterator zurück, mit dem das erste Element im Bereich behandelt wird.

const_iterator cbegin() const;

Rückgabewert

Ein const-Forward-Access-Iterator, der auf das erste Element des Bereichs zeigt oder die Position direkt hinter dem Ende eines leeren Bereichs (für einen leeren Bereich gilt cbegin() == cend()).

Hinweise

Mit dem Rückgabewert von cbegin, die Elemente im Bereich können nicht geändert werden.

Sie können diese Memberfunktion anstelle der begin()-Memberfunktion verwenden, um sicherzustellen, dass der Rückgabewert const_iterator ist. In der Regel wird sie mit dem auto Stichwort "Typabzug" verwendet, wie im folgenden Beispiel gezeigt. Im folgenden Beispiel ist Container ein beliebiger änderbarer (Nicht-const-)Container, der begin() und cbegin() unterstützt.

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();
// i2 is Container<T>::const_iterator

cend

Gibt einen const-Iterator zurück, der den Speicherort adressiert, der dem letzten Element eines Bereichs unmittelbar nachfolgt.

const_iterator cend() const;

Rückgabewert

Gibt einen -Forward-Access-Iterator zurück, der auf eine Position unmittelbar nach dem Ende des Bereichs verweist.

Hinweise

cend wird verwendet, um zu testen, ob ein Iterator das Ende seines Bereichs übergeben hat.

Sie können diese Memberfunktion anstelle der end()-Memberfunktion verwenden, um sicherzustellen, dass der Rückgabewert const_iterator ist. In der Regel wird sie mit dem auto Stichwort "Typabzug" verwendet, wie im folgenden Beispiel gezeigt. Im folgenden Beispiel ist Container ein beliebiger änderbarer (Nicht-const-)Container, der end() und cend() unterstützt.

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

Der zurückgegebene cend Wert sollte nicht abgeleitet werden.

clear

Löscht alle Elemente einer Vorwärtsliste auf.

void clear();

Hinweise

Diese Memberfunktion ruft auf erase_after(before_begin(), end()).

const_iterator

Ein Typ, der einen konstanten Iterator für die Vorwärtsliste bereitstellt.

typedef implementation-defined const_iterator;

Hinweise

const_iterator beschreibt ein Objekt, das als konstanter Forward-Iterator für die gesteuerte Sequenz fungieren kann. Es wird hier als Synonym für einen implementierungsdefinierten Typ beschrieben.

const_pointer

Ein Typ, der einen Zeiger auf ein const-Element in einer Vorwärtsliste bereitstellt.

typedef typename Allocator::const_pointer
    const_pointer;

const_reference

Ein Typ, der einen Konstantenverweis auf einer Vorwärtsliste gespeichertes Element bereitstellt.

typedef typename Allocator::const_reference const_reference;

difference_type

Ein Ganzzahltyp mit Vorzeichen, der dazu verwendet werden kann, die Anzahl von Elementen einer Vorwärtsliste in einen Bereich zwischen Elementen darzustellen, auf die von Iteratoren gezeigt wird.

typedef typename Allocator::difference_type difference_type;

Hinweise

difference_type beschreibt ein Objekt, das die Differenz zwischen den Adressen von zwei beliebigen Elementen in der gesteuerten Sequenz darstellen kann.

emplace_after

Die Verschiebung erstellt ein neues Element nach einer angegebenen Position.

template <class T>
iterator emplace_after(const_iterator Where, Type&& val);

Parameter

Where
Die Position in der forward_list-Klasse, an der das neue Element erstellt wird.

val
Das Konstruktorargument

Rückgabewert

Ein Iterator, der das neu eingefügte Element entwirft

Hinweise

Diese Memberfunktion fügt ein Element mit den Konstruktorargumenten val direkt nach dem Element ein, auf Where das in der kontrollierten Sequenz verwiesen wird. Das Verhalten ist andernfalls identisch mit forward_list::insert_after.

emplace_front

Fügt ein direkt konstruiertes Element am Anfang der Liste ein.

template <class Type>
    void emplace_front(Type&& val);

Parameter

val
Das am Anfang der Vorwärtsliste hinzugefügte Element

Hinweise

Diese Memberfunktion fügt ein Element mit den Konstruktorargumenten val am Anfang der gesteuerten Sequenz ein.

Wenn eine Ausnahme ausgelöst wird, bleibt der Container unverändert, und die Ausnahme wird erneut ausgelöst.

empty

Testet, ob eine Vorwärtsliste leer ist.

bool empty() const;

Rückgabewert

true, wenn die forward_list-Klasse leer ist, andernfalls false.

end

Gibt einen Iterator zurück, der den Speicherort adressiert, der dem letzten Element einer Vorwärtsliste nachfolgt.

const_iterator end() const;
iterator end();

Rückgabewert

Ein Forward-Iterator, der auf eine Position unmittelbar hinter dem Ende der Sequenz verweist.

erase_after

Entfernt Elemente nach einer angegebenen Position aus der Vorwärtsliste.

iterator erase_after(const_iterator Where);
iterator erase_after(const_iterator first, const_iterator last);

Parameter

Where
Die Position in der forward_list-Klasse, an der das Element gelöscht wird

first
Der Anfang des zu löschenden Bereichs

last
Das Ende des zu löschenden Bereichs

Rückgabewert

Ein Iterator, der das erste Element angibt, das über alle entfernten Elemente hinausgeht, oder forward_list::end wenn kein solches Element vorhanden ist.

Hinweise

Die erste Memberfunktion entfernt das Element der gesteuerten Sequenz direkt nach Where.

Die zweite Memberfunktion entfernt die Elemente der gesteuerten Sequenz im Bereich ( first, last) (keiner der beiden Endpunkte ist beinhaltet).

Das Löschen von N-Elementen verursacht N-Destruktoraufrufe. Eine Neuzuordnung findet statt, damit Iteratoren und Verweise für die gelöschten Elemente ungültig werden.

Von der Memberfunktionen wird nie eine Ausnahme ausgelöst.

forward_list

Konstruiert ein Objekt vom Typ forward_list.

forward_list();
explicit forward_list(const Allocator& Al);
explicit forward_list(size_type Count);
forward_list(size_type Count, const Type& Val);
forward_list(size_type Count, const Type& Val, const Allocator& Al);
forward_list(const forward_list& Right);
forward_list(const forward_list& Right, const Allocator& Al);
forward_list(forward_list&& Right);
forward_list(forward_list&& Right, const Allocator& Al);
forward_list(initializer_list<Type> IList, const Alloc& Al);
template <class InputIterator>
forward_list(InputIterator First, InputIterator Last);
template <class InputIterator>
forward_list(InputIterator First, InputIterator Last, const Allocator& Al);

Parameter

Al
Die mit diesem Objekt zu verwendende Zuweisungsklasse.

Count
Die Anzahl von Elementen in der erstellten Liste.

Val
Der Wert der Elemente in der erstellten Liste.

Right
Die Liste, deren Kopie die erstellte Liste ist.

First
Die Position des ersten Elements in dem zu kopierenden Elementbereich.

Last
Die Position des ersten Elements nach dem zu kopierenden Elementbereich.

IList
Der initializer_list zu kopierende Code.

Hinweise

Alle Konstruktoren speichern eine allocator und initialisieren die kontrollierte Sequenz. Das Allocator-Objekt ist das Argument Al, falls vorhanden. Für den Kopierkonstruktor ist right.get_allocator()es . Andernfalls ist das Ergebnis Allocator().

Die ersten beiden Konstruktoren geben eine leere gesteuerte Sequenz an.

Der dritte Konstruktor gibt eine Wiederholung der Count Werteelemente Type()an.

Die vierten und fünften Konstruktoren geben eine Wiederholung von Count Wertenelementen Valan.

Der sechste Konstruktor gibt eine Kopie der von Rechts gesteuerten Sequenz an. Wenn InputIterator ein Ganzzahltyp ist, geben die folgenden zwei Konstruktoren eine Wiederholung von (size_type)First-Elementen des Werts (Type)Last an. Andernfalls geben die folgenden zwei Konstruktoren die Sequenz [First, Last) an.

Der neunte und zehnte Konstruktor sind mit dem sechsten identisch, haben aber einen rvalue-Verweis.

Der letzte Konstruktor gibt die ursprüngliche gesteuerte Sequenz mit einem Objekt der Klasse initializer_list<Type> an.

front

Gibt einen Verweis auf das erste Element in einer Vorwärtsliste zurück.

reference front();
const_reference front() const;

Rückgabewert

Ein Verweis auf das erste Element der gesteuerten Sequenz, das nicht leer sein darf

get_allocator

Gibt eine Kopie des Zuordnungsobjekts zurück, das zum Erstellen der Vorwärtsliste verwendet wird.

allocator_type get_allocator() const;

Rückgabewert

Das gespeicherte allocator Objekt.

insert_after

Fügt der Vorwärtsliste nach einer angegebenen Position Elemente hinzu.

iterator insert_after(const_iterator Where, const Type& Val);
void insert_after(const_iterator Where, size_type Count, const Type& Val);
void insert_after(const iterator Where, initializer_list<Type> IList);
iterator insert_after(const_iterator Where, Type&& Val);
template <class InputIterator>
    void insert_after(const_iterator Where, InputIterator First, InputIterator Last);

Parameter

Where
Die Position in der Zielvorwärtsliste, an der das erste Element eingefügt wird.

Count
Die Anzahl einzufügender Elemente.

First
Der Anfang des Einfügebereichs.

Last
Das Ende des Einfügebereichs.

Val
Das Element hinzugefügt Vorwärtsliste.

IList
Der einzufügende Text initializer_list .

Rückgabewert

Ein Iterator, der das neu eingefügte Element festlegt (nur erste und letzte Memberfunktionen).

Hinweise

Jede der Memberfunktionen fügt – direkt nach dem Element, auf Where das in der gesteuerten Sequenz verwiesen wird – eine Sequenz ein, die von den verbleibenden Operanden angegeben wird.

Die erste Memberfunktion fügt ein Element ein, das einen Wert Val aufweist, und gibt einen Iterator zurück, der das neu eingefügte Element angibt.

Die zweite Memberfunktion fügt eine Wiederholung der Count Werteelemente Valein.

Wenn InputIterator ein Ganzzahltyp ist, verhält sich die dritte Memberfunktion genau wie insert(it, (size_type)First, (Type)Last). Andernfalls wird die Sequenz [First, Last) eingefügt, die die ursprüngliche gesteuerte Sequenz nicht überschneiden darf.

Die vierte Memberfunktion fügt die Sequenz ein, die vom Objekt der Klasse initializer_list<Type> angegeben wird.

Die letzte Memberfunktion ist mit der ersten identisch, hat aber einen rvalue-Verweis.

Das Einfügen von N-Elementen verursacht N-Konstruktoraufrufe. Eine Neuzuordnung erfolgt, es werden aber keine Iteratoren oder Verweise ungültig.

Wird während der Einfügung bei einem oder mehreren Elementen eine Ausnahme ausgelöst wird, wird der Container unverändert belassen, und die Ausnahme wird erneut ausgelöst.

iterator

Ein Typ, der einen Iterator für die Vorwärtsliste bereitstellt.

typedef implementation-defined iterator;

Hinweise

iterator beschreibt ein Objekt, das als Forward-Iterator für die gesteuerte Sequenz fungieren kann. Es wird hier als Synonym für einen implementierungsdefinierten Typ beschrieben.

max_size

Gibt die Maximallänge einer Vorwärtsliste zurück.

size_type max_size() const;

Rückgabewert

Die Länge der längsten Sequenz, die das Objekt steuern kann

merge

Kombiniert zwei sortierte Sequenzen zu einer einzigen sortierte Sequenz zeitlich linear. Entfernt die Elemente aus der Argumentliste und fügt sie in forward_list ein. Die beiden Listen sollten von dem gleichen Funktionenvergleichsobjekt sortiert werden, bevor merge aufgerufen wird. Die kombinierte Liste wird nach dem Funktionenvergleichsobjekt sortiert.

void merge(forward_list& right);
template <class Predicate>
    void merge(forward_list& right, Predicate comp);

Parameter

right
Die forward_list-Klasse, aus der zusammengeführt wird

comp
Der Funktionenvergleichsobjekt, das zum Sortieren der Elemente verwendet wird

Hinweise

forward_list::merge entfernt die Elemente aus dem forward_listright, und fügt sie in diese forward_listein. Beide Sequenzen müssen nach dem gleichen Prädikat sortiert werden, wie unten beschrieben. Die kombinierte Ereignissequenz wird ebenfalls nach diesem Funktionenvergleichssobjekt sortiert.

Für die Iteratoren Pi und Pj, die Elemente an den Positionen i und j festlegen, erzwingt die erste Memberfunktion die Reihenfolge !(*Pj < *Pi), immer wenn i < j vorliegt. (Die Elemente werden in ascending der reihenfolge sortiert.) Die zweite Memberfunktion legt die Reihenfolge ! comp(*Pj, *Pi) immer i < jdann fest.

In der ursprünglichen gesteuerten Sequenz werden in der resultierenden gesteuerten Sequenz keine Elementpaare rückgängig gemacht. Wenn ein Elementpaar in der resultierenden kontrollierten Sequenz gleich (!(*Pi < *Pj) && !(*Pj < *Pi)) vergleicht, wird ein Element aus der ursprünglichen gesteuerten Sequenz vor einem Element aus der von rightder Sequenz gesteuerten Sequenz angezeigt.

Eine Ausnahme tritt nur dann auf, wenn comp eine Ausnahme auslöst. In diesem Fall bleibt die gesteuerten Sequenz in einer nicht vorgegebenen Reihenfolge, und die Ausnahme wird erneut ausgelöst.

operator=

Ersetzt die Elemente der Vorwärtsliste durch eine Kopie einer anderen Vorwärtsliste.

forward_list& operator=(const forward_list& right);
forward_list& operator=(initializer_list<Type> IList);
forward_list& operator=(forward_list&& right);

Parameter

right
forward_list-Klasse, die in die forward_list-Klasse kopiert wird

IList
Ein Initialisierer mit geschweiften Klammern, der sich wie eine Sequenz von Elementen des Typs Type verhält.

Hinweise

Der erste Memberoperator ersetzt die kontrollierte Sequenz durch eine Kopie der durch right.

Der zweite Memberoperator ersetzt die gesteuerte Sequenz durch ein Objekt der Klasse initializer_list<Type>.

Die letzte Memberfunktion ist identisch mit der ersten, hat aber einen rvalue-Verweis.

pointer

Ein Typ, der einen Zeiger auf ein Element in der Vorwärtsliste bereitstellt.

typedef typename Allocator::pointer pointer;

pop_front

Löscht das Element am Anfang einer Vorwärtsliste.

void pop_front();

Hinweise

Das erste Element der forward_list-Klasse darf nicht leer sein.

Die Memberfunktionen löst nie eine Ausnahme aus.

push_front

Fügt am Anfang einer Vorwärtsliste ein Element hinzu.

void push_front(const Type& val);
void push_front(Type&& val);

Parameter

val
Das am Anfang der Vorwärtsliste hinzugefügte Element

Hinweise

Wenn eine Ausnahme ausgelöst wird, bleibt der Container unverändert, und die Ausnahme wird erneut ausgelöst.

reference

Ein Typ, der einen Verweis auf ein in der Vorwärtsliste gespeichertes Element bereitstellt.

typedef typename Allocator::reference reference;

remove

Löscht Elemente in einer Vorwärtsliste, die einem angegebenen Wert entsprechen.

void remove(const Type& val);

Parameter

val
Der Wert, der, sofern er von einem Element gehalten wird, das Entfernen dieses Elements aus der Liste verursacht.

Hinweise

Die Memberfunktion entfernt alle Elemente aus der kontrollierten Sequenz, die vom Iterator P bestimmt wurden, für den *P == val

Die Memberfunktionen löst nie eine Ausnahme aus.

remove_if

Löscht Elemente aus einer Vorwärtsliste, für die ein angegebenes Prädikat erfüllt ist.

template <class Predicate>
    void remove_if(Predicate pred);

Parameter

pred
Das unäre Prädikat, das bei Erfüllung durch ein Element das Löschen dieses Elements in der Liste zur Folge hat.

Hinweise

Die Memberfunktion entfernt alle Elemente aus der kontrollierten Sequenz, die vom Iterator P bestimmt wurden, für den pred(*P) TRUE ist.

Eine Ausnahme tritt nur dann auf, wenn pred eine Ausnahme auslöst. In diesem Fall bleibt die gesteuerten Sequenz in einem nicht vorgegebenen Zustand, und die Ausnahme wird erneut ausgelöst.

resize

Gibt eine neue Größe für eine Vorwärtsliste an.

void resize(size_type _Newsize);
void resize(size_type _Newsize, const Type& val);

Parameter

_Newsize
Die Anzahl der Elemente im Vorwärtsliste, deren Größe angepasst wurde

val
Der für die Auffüllung zu nutzende Wert

Hinweise

Die Memberfunktionen stellen beide sicher, dass die Anzahl der Elemente in der Liste daher lautet _Newsize. Wenn die kontrollierte Sequenz länger sein muss, fügt die erste Memberfunktion Elemente mit Dem Wert Type()an, während die zweite Memberfunktion Elemente mit dem Wert valanfüge. Damit die gesteuerte Sequenz kürzer wird, rufen beide Memberfunktionen erase_after(begin() + _Newsize - 1, end()) auf.

reverse

Kehrt die Reihenfolge um, in der die Elemente in einer Vorwärtsliste auftreten.

void reverse();

size_type

Ein Typ, der den Abstand ohne Vorzeichen zwischen zwei Elementen darstellt.

typedef typename Allocator::size_type size_type;

Hinweise

Der unsignierte Ganzzahltyp beschreibt ein Objekt, das die Länge jeder kontrollierten Sequenz darstellen kann.

sort

Ordnet die Elemente in aufsteigender Reihenfolge oder einer durch ein Prädikat angegebenen Reihenfolge.

void sort();
template <class Predicate>
void sort(Predicate pred);

Parameter

pred
Das Sortierungsprädikat

Hinweise

Beide Memberfunktionen sortieren die Elemente in der gesteuerten Sequenz mithilfe eines Prädikats, wie unten beschrieben.

Für die Iteratoren Pi und Pj, die Elemente an den Positionen i und j festlegen, erzwingt die erste Memberfunktion die Reihenfolge !(*Pj < *Pi), immer wenn i < j vorliegt. (Die Elemente werden in ascending der reihenfolge sortiert.) Die Elementvorlagenfunktion legt die Reihenfolge ! pred(*Pj, *Pi) immer i < jdann fest. In der ursprünglichen gesteuerten Sequenz werden in der resultierenden gesteuerten Sequenz keine sortierten Elementpaare rückgängig gemacht. (Die Sortierung ist stabil.)

Eine Ausnahme tritt nur dann auf, wenn pred eine Ausnahme auslöst. In diesem Fall bleibt die gesteuerten Sequenz in einer nicht vorgegebenen Reihenfolge, und die Ausnahme wird erneut ausgelöst.

splice_after

Entfernt Elemente aus einer Quelle forward_list und fügt sie in ein Ziel forward_listein.

// insert the entire source forward_list
void splice_after(const_iterator Where, forward_list& Source);
void splice_after(const_iterator Where, forward_list&& Source);

// insert one element of the source forward_list
void splice_after(const_iterator Where, forward_list& Source, const_iterator Iter);
void splice_after(const_iterator Where, forward_list&& Source, const_iterator Iter);

// insert a range of elements from the source forward_list
void splice_after(
    const_iterator Where,
    forward_list& Source,
    const_iterator First,
    const_iterator Last);

void splice_after(
    const_iterator Where,
    forward_list&& Source,
    const_iterator First,
    const_iterator Last);

Parameter

Where
Die Position im Ziel forward_list , nach der eingefügt werden soll.

Source
Die Quelle forward_list , die in das Ziel forward_listeingefügt werden soll.

Iter
Das Element, das aus der Quelle forward_listeingefügt werden soll.

First
Das erste Element im Bereich, das aus der Quelle forward_listeingefügt werden soll.

Last
Die erste Position außerhalb des Bereichs, der aus der Quelle forward_listeingefügt werden soll.

Hinweise

Das erste Elementfunktionspaar fügt die Sequenz ein, die direkt Source nach dem Element in der kontrollierten Abfolge gesteuert wird Where, auf die verwiesen wird. Außerdem werden alle Elemente aus Sourceentfernt. ( &Source darf nicht gleich this sein.)

Das zweite Elementpaar von Memberfunktionen entfernt das Element direkt nach Iter der von dieser gesteuerten Source Sequenz und fügt es direkt nach dem Element in der kontrollierten Sequenz ein, auf die Whereverwiesen wird. (Wenn Where == Iter || Where == ++Iter ist, findet keine Änderung statt.)

Das dritte Elementfunktionspaar (Bereichsspliz) fügt das von der Sequenz festgelegte (First, Last)Source Subrange direkt nach dem Element in der kontrollierten Abfolge ein, auf die verwiesen Wherewird. Es entfernt auch den ursprünglichen Unterbereich aus der Sequenz, die von Source. (Wenn &Source == this, darf der Bereich (First, Last) nicht das Element enthalten, auf das durch Where.)

Wenn der Bereichsspliz Elemente einfügt N und &Source != thisein Objekt der Klasse iterator inkrementiert N wird.

Keine Iteratoren, Zeiger oder Verweise, die zusammengeführte Elemente bezeichnen, werden ungültig.

Beispiel

// forward_list_splice_after.cpp
// compile with: /EHsc /W4
#include <forward_list>
#include <iostream>

using namespace std;

template <typename S> void print(const S& s) {
    for (const auto& p : s) {
        cout << "(" << p << ") ";
    }

    cout << endl;
}

int main()
{
    forward_list<int> c1{ 10, 11 };
    forward_list<int> c2{ 20, 21, 22 };
    forward_list<int> c3{ 30, 31 };
    forward_list<int> c4{ 40, 41, 42, 43 };

    forward_list<int>::iterator where_iter;
    forward_list<int>::iterator first_iter;
    forward_list<int>::iterator last_iter;

    cout << "Beginning state of lists:" << endl;
    cout << "c1 = ";
    print(c1);
    cout << "c2 = ";
    print(c2);
    cout << "c3 = ";
    print(c3);
    cout << "c4 = ";
    print(c4);

    where_iter = c2.begin();
    ++where_iter; // start at second element
    c2.splice_after(where_iter, c1);
    cout << "After splicing c1 into c2:" << endl;
    cout << "c1 = ";
    print(c1);
    cout << "c2 = ";
    print(c2);

    first_iter = c3.begin();
    c2.splice_after(where_iter, c3, first_iter);
    cout << "After splicing the first element of c3 into c2:" << endl;
    cout << "c3 = ";
    print(c3);
    cout << "c2 = ";
    print(c2);

    first_iter = c4.begin();
    last_iter = c4.end();
    // set up to get the middle elements
    ++first_iter;
    c2.splice_after(where_iter, c4, first_iter, last_iter);
    cout << "After splicing a range of c4 into c2:" << endl;
    cout << "c4 = ";
    print(c4);
    cout << "c2 = ";
    print(c2);
}

Beginning state of lists:c1 = (10) (11)c2 = (20) (21) (22)c3 = (30) (31)c4 = (40) (41) (42) (43)After splicing c1 into c2:c1 =c2 = (20) (21) (10) (11) (22)After splicing the first element of c3 into c2:c3 = (30)c2 = (20) (21) (31) (10) (11) (22)After splicing a range of c4 into c2:c4 = (40) (41)c2 = (20) (21) (42) (43) (31) (10) (11) (22)

swap

Tauscht die Elemente zweier Vorwärtslisten aus.

void swap(forward_list& right);

Parameter

right
Die forward_list-Klasse, die auszutauschende Elemente bereitstellt

Hinweise

Die Memberfunktion tauscht die kontrollierten Sequenzen zwischen *this und right aus. Wenn get_allocator() == right.get_allocator(), führt sie dies in einer konstanten Zeit aus, löst keine Ausnahmen aus und macht keine Verweise, Zeiger oder Iteratoren ungültig, die Elemente in den beiden gesteuerten Sequenzen bestimmen. Andernfalls werden Elementzuweisungen und Konstruktoraufrufe proportional zur Anzahl der Elemente in den beiden gesteuerten Sequenzen ausgeführt.

unique

Entfernt alle bis auf das erste Element aus jeder aufeinander folgenden Gruppe gleicher Elemente

void unique();
template <class BinaryPredicate>
void unique(BinaryPredicate comp);

Parameter

comp
Das binäre Prädikat, das zum Vergleichen von aufeinander folgenden Elementen verwendet wird.

Hinweise

Behält das erste von jedem eindeutigen Element und entfernt die übrigen Die Elemente müssen sortiert werden, sodass Elemente mit gleichem Wert in der Liste nebeneinander angezeigt werden.

Die erste Memberfunktion entfernt jedes Element aus der gesteuerten Sequenz, das identisch mit dem vorherigen Element ist. Für die Iteratoren Pi und Pj, die Elemente an den Positionen i und j bestimmen, entfernt die zweite Memberfunktion jedes Element, für das i + 1 == j && comp(*Pi, *Pj) gilt.

Bei einer kontrollierten Längenfolge N (> 0) wird das Prädikat comp(*Pi, *Pj) mal ausgewertet N - 1 .

Eine Ausnahme tritt nur dann auf, wenn comp eine Ausnahme auslöst. In diesem Fall bleibt die gesteuerten Sequenz in einem nicht vorgegebenen Zustand, und die Ausnahme wird erneut ausgelöst.

value_type

Ein Typ, der den Typ des in einer Vorwärtsliste gespeicherten Elements darstellt.

typedef typename Allocator::value_type value_type;

Hinweise

Der Type stellt ein Synonym für den Vorlagenparameter Typedar.