forward_list Class

Descreve um objeto que controla uma seqüência de comprimento variando de elementos.A seqüência é armazenada como uma lista vinculada singularmente de nós, cada um contendo um membro do 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 ();
};

Parâmetros

Parâmetro	Descrição
Type	O tipo de dados do elemento para ser armazenado na forward_list.
_Alloc	O objeto alocador armazenados que encapsula os detalhes sobre a forward_list alocação e desalocação de memória.Este parâmetro é opcional.O valor padrão é alocador <Type>.
_Count	O número de elementos em um forward_list.
_Val	O elemento para adicionar o forward_list.
_Right	A lista para incorporar o forward_list.
_Pos	O iterador indicando um local de forward_list.
_First	O iterador indicando o local de início de um intervalo de elementos de forward_list.
_Last	O iterador indicando o local final de um intervalo de elementos de forward_list.
_Init	A lista do inicializador
_List	Forward_list para mesclar, unir ou atribuir de.
_Comp	A função de comparação.

Comentários

A forward_list objeto aloca e libera o armazenamento para a seqüência que ele controla por meio de um objeto armazenado da classe Allocator baseado em allocator Class (conhecido como std::allocator).Para mais informações, consulte Allocators.Um objeto alocador deve ter a mesma interface externa como um objeto de classe de modelo allocator.

Observação
O objeto de alocador armazenado não é copiado quando o objeto de contêiner é atribuído.

Iteradores, referências e ponteiros podem se tornar inválidas quando elementos de sua seqüência controlada são apagados por meio de forward_list.Inserções e partes executadas na seqüência controlada por meio de forward_list invalida iteradores.

Adições a seqüência controlada podem ocorrer por chamadas para forward_list::insert_after, que é a única função de membro chama o construtor Type(const _Type&).forward_listtambém pode ser chamada mover construtores.Se uma expressão como essa lança uma exceção, o objeto de contêiner não insere nenhum novos elementos e Relança a exceção.Assim, um objeto de classe de modelo forward_list é deixado em um estado conhecido quando essas exceções ocorrem.

Construtores

forward_list

Constrói um objeto do tipo forward_list.

Typedefs

allocator_type	Um tipo que representa a classe de alocador de um objeto de lista de encaminhamento.
const_iterator	Um tipo que fornece um iterador constante para a lista de encaminhamento.
const_pointer	Um tipo que fornece um ponteiro para um const elemento em uma lista de encaminhamento.
const_reference	Um tipo que fornece uma referência constante a um elemento na lista de encaminhamento.
difference_type	Um tipo inteiro assinado que pode ser usado para representar o número de elementos de uma lista de encaminhamento em um intervalo entre elementos apontada por iteradores.
iterador	Um tipo que fornece um iterador para a lista de encaminhamento.
ponteiro	Um tipo que fornece um ponteiro para um elemento na lista de encaminhamento.
referência	Um tipo que fornece uma referência a um elemento na lista de encaminhamento.
size_type	Um tipo que representa a distância não assinada entre dois elementos.
value_type	Um tipo que representa o tipo de elemento armazenado em uma lista de encaminhamento.

Funções de membro

atribuir	Apaga os elementos de uma lista de encaminhamento e copia um novo conjunto de elementos de uma lista de encaminhamento de destino.
before_begin	Retorna um iterador endereçamento posição antes do primeiro elemento em uma lista de encaminhamento.
início	Retorna um iterador endereçamento do primeiro elemento em uma lista de encaminhamento.
cbefore_begin	Retorna um iterador const endereçamento posição antes do primeiro elemento em uma lista de encaminhamento.
cbegin	Retorna um iterador const endereçamento do primeiro elemento em uma lista de encaminhamento.
cend	Retorna um iterador const que aborda o local subseqüente do último elemento em uma lista de encaminhamento.
Limpar	Apaga todos os elementos de uma lista de encaminhamento.
emplace_after	Mover constrói um novo elemento após uma posição especificada.
emplace_front	Adiciona um elemento construído no local para o início da lista.
vazio	Testa se uma lista de encaminhamento está vazia.
fim	Retorna um iterador que aborda o local subseqüente do último elemento em uma lista de encaminhamento.
erase_after	Remove os elementos da lista de encaminhamento após uma posição especificada.
frontal	Retorna uma referência ao primeiro elemento em uma lista de encaminhamento.
get_allocator	Retorna uma cópia do objeto alocador usado para construir uma lista de encaminhamento.
insert_after	Adiciona elementos à lista direta após uma posição especificada.
max_size	Retorna o comprimento máximo de uma lista de encaminhamento.
mala direta	Remove os elementos da lista de argumento, insere a lista de encaminhamento de destino e ordena o conjunto novo, combinado de elementos em ordem crescente ou em alguma ordem especificada.
pop_front	Exclui o elemento no início de uma lista de encaminhamento.
push_front	Adiciona um elemento ao início de uma lista de encaminhamento.
remover	Apaga os elementos em uma lista de encaminhamento que corresponde ao valor especificado.
remove_if	Apaga os elementos de uma lista de encaminhamento para o qual um predicado especificado for satisfeito.
redimensionar	Especifica um novo tamanho de uma lista de encaminhamento.
inversa	Inverte a ordem na qual os elementos ocorrem em uma lista de encaminhamento.
classificação	Organiza os elementos em ordem crescente ou com uma ordem especificada por um predicado.
splice_after	Restitches links entre os nós.
troca	Troca dos elementos de duas listas de encaminhamento.
exclusivo	Remove elementos adjacentes que passar um teste especificada.

Operadores

operador =

Substitui os elementos da lista de encaminhamento com uma cópia de outra lista de encaminhamento.

Requisitos

Cabeçalho: <forward_list>

Namespace: std

Consulte também

Referência

<forward_list>

Outros recursos

<forward_list> Membros