forward_list Class

Beschreibt ein Objekt, das eine Folge variabler Länge von Elementen steuert.Die Folge ist gespeichert als eine einfach verknüpfte Liste von Knoten, jeweils einen Member des Typs Type.

template<class Type, class Allocator = allocator<Type> >
    class forward_list {
public:
    typedef Allocator allocator_type;
    typedef typename Allocator::pointer pointer;
    typedef typename Allocator::const_pointer
        const_pointer;
    typedef typename Allocator::reference reference;
    typedef typename Allocator::const_reference const_reference;
    typedef typename Allocator::value_type value_type;
    typedef typename Allocator::size_type size_type;
    typedef typename Allocator::difference_type difference_type;

    typedef T0 iterator;
    typedef T1 const_iterator;

    forward_list();
    explicit forward_list(const Allocator& _Alloc);
    explicit forward_list(size_type _Count);
    forward_list(
        size_type _Count, 
        const Type& _Val
    );
    forward_list(
        size_type _Count, 
        const Type& _Val, 
        const Allocator& _Alloc
    );
    forward_list(const forward_list& _Right);
    template<class InputIterator>
        forward_list (
            InputIterator _First, 
            InputIterator _Last
);
    template<class InputIterator>
        forward_list (
            InputIterator _First,
            InputIterator _Last, 
            const Allocator& _Alloc
);

    forward_list (initializer_list<Type> _Init)
    forward_list (
        initializer_list<Type> _Init,
        const Allocator& _Alloc
);
    forward_list (forward_list&& _Right);
 
    ~forward_list();

    forward_list& operator= (const forward_list& _Right);
    forward_list& operator= (forward_list&& _Right);

    iterator before_begin ();
    const_iterator before_begin () const;
    iterator begin ();
    const_iterator begin () const;
    iterator end ();
    const_iterator end () const;

    const_iterator cbefore_begin () const;
    const_iterator cbegin () const;
    const_iterator cend () const;

    void resize (size_type _Count);
    void resize (
        size_type _Count, 
        const Type& _Val
    );
    size_type max_size () const;
    bool empty () const;

    Alloc get_allocator () const;

    reference front ();
    const_reference front () const;

    void push_front (const Type& _Val);
    void push_front (Type&& _Val);
    template<class _Type>
        void emplace_front(_Type&& _Val);
    void pop_front ();

    template<class InputIterator>
        void assign (
            InputIterator _First, 
            InputIterator _Last
);
    void assign (
        size_type _Count, 
        const Type& _Val
    );

    iterator insert_after (
        const_iterator _Pos, 
        const Type& _Val
    );
    void insert_after (
        const_iterator _Pos, 
        size_type _Count, 
        const Type& _Val
    );
    template<class InputIterator >
        void insert_after (
            const_iterator _Pos, 
            InputIterator _First, 
            InputIterator _Last
        );
    void insert_after (
        const iterator _Pos, 
        initializer_list<Type> _Init
)
    iterator insert_after (
        const_iterator _Pos, 
        Type&& _Val
    );
    template<class Type>
        iterator emplace_after(const_iterator _Where, Type&& _Val);
    iterator erase_after (const_iterator _Pos);
    iterator erase_after (
        const_iterator _First, 
        const_iterator _Last
    );
    void clear ();

    void swap (forward_list& _Right);

    void splice_after (
        const_iterator _Pos, 
        forward_list& _List
    );
    void splice_after (
        const_iterator _Pos, 
        forward_list& _List, 
        iterator _First
    );
    void splice_after (
        const_iterator _Pos, 
        forward_list& _List, 
        iterator _First,
        iterator _Last);

    void remove (const Type& _Val);
    template<class Predicate>
        void remove_if (Predicate _Pred);
    void unique ();
    template<class BinaryPredicate>
        void unique (BinaryPredicate _Comp);

    void merge (forward_list& _List);
    template<class BinaryPredicate>
        void merge (
            forward_list& _List, 
            BinaryPredicate _Comp
);
    void sort ();
    template<class BinaryPredicate>
        void sort (BinaryPredicate _Comp);
    void reverse ();
};

Parameter

Parameter	Beschreibung
Type	Der Element-Datentyp in der Forward_list gespeichert werden.
_Alloc	Das gespeicherte Zuweisung-Objekt, das Details über die Forward_list-Zuweisung und Freigabe des Speichers kapselt.Dieser Parameter ist optional.Der Standardwert ist Zuweisung <Type>.
_Count	Die Anzahl der Elemente in einer Forward_list.
_Val	Das Element hinzufügen zu den forward_list.
_Right	Die Liste zu berücksichtigen die forward_list.
_Pos	Der Iterator, der angibt, einer Position in der forward_list.
_First	Der Iterator, der angibt, den Startspeicherort für einen Bereich von Elementen in der forward_list.
_Last	Der Iterator, der angibt, der die Endposition für einen Bereich von Elementen in der forward_list.
_Init	Die Liste der Konstruktorinitialisierungen
_List	Forward_list zusammenführen möchten, weisen Sie aus oder spleißen.
_Comp	Die Vergleichsfunktion.

Hinweise

A forward_list Objekt reserviert und freigegeben von Speicher für die Sequenz durch ein gespeicherte Objekt der Klasse gesteuert Allocator , basiert auf allocator Class (bekannt als std::allocator).Weitere Informationen finden Sie unter Belegungsfunktionen.Ein Objekt Zuweisung müssen die gleiche externe Schnittstelle als ein Objekt der Vorlage-Klasse allocator.

Hinweis
Gespeicherte Zuweisung-Objekts wird nicht kopiert, wenn das Containerobjekt zugewiesen wird.

Iteratoren, Zeiger und Verweise möglicherweise werden ungültig, wenn ihre kontrollierten Sequenz Elemente, durch gelöscht werden forward_list.Einfügungen und Stöße durchgeführt, auf die kontrollierte Sequenz durch forward_list Iteratoren nicht ungültig.

Ergänzungen zu der kontrollierten Sequenz auftreten durch Aufrufe von forward_list::insert_after, ist die einzige Memberfunktion, die der Konstruktor ruft Type(const _Type&).forward_listAnruf kann Konstruktoren auch verschoben werden.Wenn ein solcher Ausdruck eine Ausnahme auslöst, wird das Containerobjekt fügt keine neuen Elemente und löst die Ausnahme erneut aus.Damit ein Objekt der Vorlagenklasse forward_list in einen bekannten Zustand belassen wird, wenn solche Ausnahmen auftreten.

Konstruktoren

forward_list

Erstellt ein Objekt vom Typ forward_list.

Typedefs

allocator_type	Ein Typ, der die Zuweisung-Klasse für eine forward Listenobjekt darstellt.
const_iterator	Ein Typ, der eine Konstante Iterator für die forward Liste bereitstellt.
const_pointer	Ein Typ, der einen Zeiger auf eine const -Element in einer forward-Liste.
const_reference	Ein Typ, der einen konstanten Verweis auf ein Element in der Liste weiterleiten bereitstellt.
difference_type	Ein Ganzzahl-Typ, der verwendet werden kann, um die Anzahl der Elemente einer forward-Liste in einem Bereich zwischen den Elementen auf Iteratoren verweist darzustellen.
Iterator	Ein Typ, der einen Iterator für die forward Liste bereitstellt.
pointer	Ein Typ, der einen Zeiger auf ein Element in der Liste weiterleiten bereitstellt.
-Referenz	Ein Typ, der einen Verweis auf ein Element in der Liste weiterleiten bereitstellt.
size_type	Ein Typ, der den nicht signierten Abstand zwischen zwei Elementen darstellt.
value_type	Ein Typ, der den Typ des Elements in einer forward-Liste gespeichert darstellt.

Member-Funktionen

assign	Löscht Elemente aus einer forward-Liste, und kopiert einen neuen Satz von Elementen in einer Zielliste weiterleiten.
before_begin	Gibt einen Iterator Adressierung die Position vor das erste Element in einer forward-Liste.
begin	Gibt einen Iterator Adressierung das erste Element in einer forward-Liste.
cbefore_begin	Gibt einen const Iterator Adressierung die Position vor das erste Element in einer forward-Liste.
cbeginkönnen	Gibt einen const Iterator Adressierung das erste Element in einer forward-Liste zurück.
cend	Gibt einen const Iterator, die den Speicherort, das letzte Element in einer forward-Liste.
clear	Löscht alle Elemente einer forward-Liste.
emplace_after	Verschieben erstellt ein neues Element nach einer angegebenen Position.
emplace_front	Fügt ein Element in der Ort, an den Anfang der Liste erstellt.
empty	Testet, ob eine forward-Liste leer ist.
end	Gibt einen Iterator, die den Speicherort, das letzte Element in einer forward-Liste zurück.
erase_after	Entfernt Elemente aus der Liste weiterleiten nach einer angegebenen Position.
front	Gibt einen Verweis auf das erste Element in einer forward-Liste zurück.
get_allocator	Gibt eine Kopie des zum Erstellen einer forward-Liste verwendeten Zuweisung-Objekts zurück.
insert_after	Fügt Elemente der Liste weiterleiten nach einer angegebenen Position.
max_size	Gibt die maximale Länge einer forward-Liste zurück.
zusammenführen	Entfernt Elemente aus der Argumentliste, fügt der Zielliste weiterleiten und die neue, kombinierte Menge der Elemente in aufsteigender Reihenfolge oder in der angegebenen Reihenfolge sortiert.
pop_front	Löscht das Element am Anfang einer forward-Liste.
push_front	Fügt ein Element an den Anfang einer forward-Liste.
remove	Löscht Elemente in einer forward-Liste, die einen angegebenen Wert entspricht.
remove_if	Löscht Elemente aus einer forward-Liste für die ein angegebenes Prädikat erfüllt ist.
resize	Gibt eine neue Größe für eine forward-Liste.
Reverse	Kehrt die Reihenfolge der Elemente in einer forward-Liste.
sort	Ordnet die Elemente in aufsteigender Reihenfolge oder mit einer Bestellung durch ein Prädikat angegeben.
splice_after	Restitches Verknüpfungen zwischen Knoten.
Swap	Tauscht die Elemente der beiden forward Listen.
unique	Entfernt benachbarte Elemente, die einen angegebenen Test bestehen.

Operatoren

operator=

Die Elemente der Liste weiterleiten ersetzt mit einer Kopie einer anderen forward Liste.

Anforderungen

Header: <forward_list>

Namespace: std

Siehe auch

Referenz

<forward_list>

Weitere Ressourcen

<forward_list> Member