forward_list Class

Popisuje objekt, který řídí různé délky pořadí prvků.Pořadí je uložen jako jednotlivě propojený seznam uzlů, každá obsahuje člena typu 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 ();
};

Parametry

Parametr	Description
Type	Typ datového prvku uložené v forward_list.
_Alloc	Objekt uložené přidělování zapouzdří podrobnosti o forward_list přidělování a navracení zpět paměti.Tento parametr je volitelný.Výchozí hodnota je přidělování <Type>.
_Count	Počet prvků forward_list.
_Val	Prvek přidat forward_list.
_Right	Začlenit do seznamu forward_list.
_Pos	Iterační označující umístění forward_list.
_First	Iterační označující umístění prvků v oblasti start forward_list.
_Last	Iterační označující konec umístění prvků v oblasti forward_list.
_Init	Seznam inicializátor
_List	Forward_list sloučení, splice nebo přiřadit.
_Comp	Funkce porovnání.

Poznámky

A forward_list objekt přidělení a uvolnění úložiště pro řadu ovládacích prvků prostřednictvím objektu třídy uložené Allocator založené na allocator Class (běžně známý jako std::allocator).Další informace naleznete v tématu Allocators.Přidělování objekt musí mít stejné externí rozhraní jako objekt šablony třídy allocator.

[!POZNÁMKA]

Objekt uložené přidělování nebudou zkopírovány při přiřazení objektu kontejneru.

U iterátorů, ukazatele a odkazy stát neplatnými při jejich řízené pořadí prvků jsou vymazány až forward_list.Vkládání a zapletení provádět řízené sekvence prostřednictvím forward_list nečiní u iterátorů.

Dodatky k řízené sekvence může dojít k volání na forward_list::insert_after, která je pouze členské funkce volání konstruktoru Type(const _Type&).forward_listmůže také volání přesunout konstruktory.Pokud takový výraz výjimku, objekt kontejneru vloží žádné nové skutečnosti a znovu výjimku.Tedy objekt šablony třídy forward_list při výskytu těchto výjimek je vlevo do známého stavu.

Konstruktory

forward_list

Vytvoří objekt typu forward_list.

Funkce TypeDef

allocator_type	Typ, který představuje třídu přidělování pro objekt dopředu seznamu.
const_iterator	Typ, který poskytuje konstantní iterace seznamu vpřed.
const_pointer	Typ, který obsahuje ukazatel na const prvků seznamu vpřed.
const_reference	Typ, který poskytuje konstantní odkaz na prvek v seznamu vpřed.
difference_type	Typu se znaménkem představující počet prvků v rozsahu mezi prvky odkazuje u iterátorů dopředu seznamu lze použít.
iterace	Typ, který poskytuje iterace seznamu vpřed.
ukazatel	Typ, který obsahuje ukazatel na prvek v seznamu vpřed.
odkaz	Typ, který poskytuje odkaz na prvek v seznamu vpřed.
size_type	Typ, který představuje nepodepsané vzdálenost mezi dvěma prvky.
value_type	Typ, který představuje typ prvku uložených v seznamu vpřed.

Funkce členů

přiřadit	Vymaže prvky ze seznamu vpřed a zkopíruje nové sady prvků seznamu cílových vpřed.
before_begin	Vrátí iterace adresování umístění před první prvek v seznamu vpřed.
začít	Vrátí iterace adresování první prvek seznamu vpřed.
cbefore_begin	Vrátí const iterační adresování umístění před první prvek v seznamu vpřed.
cbegin	Vrátí const iterační adresování první prvek seznamu vpřed.
cend	Vrátí iterační const, který řeší umístění následných poslední prvek v seznamu vpřed.
Vymazat	Vymaže všechny prvky seznamu vpřed.
emplace_after	Přesunout, vytvoří nový prvek po určené pozici.
emplace_front	Přidá prvek konstruovány umístit na začátek seznamu.
prázdné	Ověřuje, zda dopředu seznam je prázdný.
Konec	Vrátí iterace, který řeší umístění následných poslední prvek v seznamu vpřed.
erase_after	Odebere prvky ze seznamu vpřed po určené pozici.
přední	Vrátí odkaz na první prvek seznamu vpřed.
get_allocator	Vrátí kopii objektu přidělování používá pro sestavení seznamu vpřed.
insert_after	Přidá prvky seznamu vpřed po určené pozici.
max_size	Vrátí maximální délka seznamu vpřed.
sloučení	Odebere ze seznamu argumentů prvků, vkládá do seznamu cílových vpřed a objednávky nové kombinované sady vzestupně nebo v některé zadané pořadí prvků.
pop_front	Odstraní prvek na začátku seznamu vpřed.
push_front	Prvek přidá na začátek seznamu vpřed.
odebrat	Vymaže prvků v seznamu vpřed, který odpovídá zadané hodnotě.
remove_if	Smaže prvky dopředu seznamu, pro který je splněna zadaná predikát.
změnit velikost	Určuje novou velikost seznam vpřed.
zpětné	Změní pořadí v prvky se objevují v seznamu vpřed.
řazení	Uspořádá prvky vzestupně nebo objednávku určenou predikátu.
splice_after	Restitches propojení mezi uzly.
Zaměnit	Výměny prvky dva seznamy vpřed.
Jedinečný	Odebere zadaný zkoušce sousedící prvky.

Operátory

operátor =

Nahradí kopie jiného seznamu dopředu prvků seznamu vpřed.

Požadavky

Záhlaví: <forward_list>

Obor názvů: std

Viz také

Referenční dokumentace

<forward_list>

Další zdroje

<forward_list> Členové