forward_list Class

In questo articolo viene descritto un oggetto che controlla una sequenza di lunghezza variabile di elementi.La sequenza viene memorizzata come un elenco collegato singolarmente di nodi, ognuno dei quali contiene un membro di tipo 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 ();
};

Parametri

Parametro	Descrizione
Type	Il tipo di dati dell'elemento da memorizzare nella forward_list.
_Alloc	L'oggetto allocatore stored che incapsula i dettagli sulle forward_list allocazione e deallocazione della memoria.Questo parametro è facoltativo.Il valore predefinito è allocatore <Type>.
_Count	Il numero di elementi in un forward_list.
_Val	L'elemento da aggiungere per il forward_list.
_Right	L'elenco per incorporare il forward_list.
_Pos	L'iteratore che indica una posizione all'interno di forward_list.
_First	L'iteratore che indica la posizione iniziale per un intervallo di elementi di forward_list.
_Last	L'iteratore che indica la posizione di fine per un intervallo di elementi di forward_list.
_Init	L'elenco di inizializzatori
_List	Forward_list per unire, giunzione o assegnare da.
_Comp	Funzione di confronto.

Note

A forward_list oggetto alloca e libera spazio di archiviazione per la sequenza è controllato attraverso un oggetto memorizzato della classe Allocator che si basa su allocator Class (comunemente conosciuto come std::allocator).Per ulteriori informazioni, vedere Allocatori.Un oggetto allocatore deve avere la stessa interfaccia esterna come oggetto di classe template allocator.

[!NOTA]

L'oggetto stored allocatore non viene copiato quando viene assegnato l'oggetto contenitore.

Gli iteratori, i puntatori e riferimenti potrebbero risultare non validi quando vengono cancellati gli elementi della loro sequenza controllata tramite forward_list.Gli inserimenti e giunti eseguita sulla sequenza controllata tramite forward_list non invalidano gli iteratori.

Potrebbero verificarsi aggiunte alla sequenza controllata dalle chiamate a forward_list::insert_after, che è l'unica funzione membro che chiama il costruttore Type(const _Type&).forward_listpotrebbe essere chiamata spostare anche i costruttori.Se un'espressione genera un'eccezione, è possibile che l'oggetto contenitore non inserito nessun nuovo elemento e genera nuovamente l'eccezione.In questo modo, un oggetto di classe template forward_list viene lasciato in uno stato noto quando si verificano tali eccezioni.

Costruttori

forward_list

Costruisce un oggetto di tipo forward_list.

Definizioni typedef

allocator_type	Un tipo che rappresenta la classe allocatore per un oggetto list diretta.
const_iterator	Un tipo che fornisce un iteratore costante per l'elenco di inoltro.
const_pointer	Un tipo che fornisce un puntatore a un const elemento in un elenco di inoltro.
const_reference	Un tipo che fornisce un riferimento costante per un elemento nell'elenco di inoltro.
difference_type	Un tipo di valore integer con segno che può essere utilizzato per rappresentare il numero di elementi di un elenco di inoltro in un intervallo tra gli elementi a cui punta iteratori.
iteratore	Un tipo che fornisce un iteratore per l'elenco di inoltro.
pointer	Un tipo che fornisce un puntatore a un elemento nell'elenco di inoltro.
Riferimento	Un tipo che fornisce un riferimento a un elemento nell'elenco di inoltro.
size_type	Tipo che rappresenta la distanza tra due elementi senza segno.
value_type	Un tipo che rappresenta il tipo di elemento memorizzato in un elenco di inoltro.

Funzioni membro

assign	Cancella gli elementi da un elenco di inoltro e copia di un nuovo insieme di elementi in un elenco di inoltro di destinazione.
before_begin	Restituisce un iteratore indirizzamento la posizione prima del primo elemento in un elenco di inoltro.
begin	Restituisce un iteratore di indirizzamento del primo elemento in un elenco di inoltro.
cbefore_begin	Restituisce un iteratore const indirizzamento la posizione prima del primo elemento in un elenco di inoltro.
cbegin	Restituisce un iteratore const indirizzamento del primo elemento in un elenco di inoltro.
cend	Restituisce un iteratore const che risolve il percorso che seguono l'ultimo elemento in un elenco di inoltro.
clear	Cancella tutti gli elementi di un elenco di inoltro.
emplace_after	Spostamento costruisce un nuovo elemento dopo una posizione specificata.
emplace_front	Aggiunge un elemento costruito posto all'inizio dell'elenco.
empty	Verifica se un elenco di inoltro è vuoto.
end	Restituisce un iteratore che risolve il percorso che seguono l'ultimo elemento in un elenco di inoltro.
erase_after	Rimuove gli elementi dall'elenco Avanti dopo una posizione specificata.
front	Restituisce un riferimento al primo elemento di un elenco di inoltro.
get_allocator	Restituisce una copia dell'oggetto allocatore utilizzato per creare un elenco di inoltro.
insert_after	Aggiunge elementi all'elenco Avanti dopo una posizione specificata.
max_size	Restituisce la lunghezza massima di un elenco di inoltro.
unione	Rimuove gli elementi dall'elenco di argomenti, li inserisce nell'elenco destinazione diretta e ordina il set di nuovo, combinato di elementi in ordine crescente o in un altro ordine specificato.
pop_front	Elimina l'elemento all'inizio di un elenco di inoltro.
push_front	Aggiunge un elemento all'inizio di un elenco di inoltro.
remove	Cancellare gli elementi in un elenco diretta che corrisponde al valore specificato.
remove_if	Cancellare gli elementi da un elenco di inoltro per il quale ha accertato un predicato specificato.
resize	Specifica una nuova dimensione per un elenco di inoltro.
inversa	Inverte l'ordine in cui si verificano gli elementi in un elenco di inoltro.
sort	Dispone gli elementi in ordine crescente o con un ordine specificato da un predicato.
splice_after	Restitches i collegamenti tra i nodi.
scambio	Scambia gli elementi di due elenchi di inoltro.
univoco	Rimuove elementi adiacenti che superano un test specificato.

Operatori

operator=

Sostituisce gli elementi dell'elenco diretta con una copia di un altro elenco di inoltro.

Requisiti

Intestazione: <forward_list>

Spazio dei nomi: std

Vedere anche

Riferimenti

<forward_list>

Altre risorse

<forward_list> membri