forward_list Class

Artículo
03/27/2013

Describe un objeto que controla una secuencia de longitud varía de elementos.La secuencia se almacena como una lista vinculada individuamente de nodos, cada uno con un miembro de 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	Descripción
Type	El tipo de datos de elemento se almacena en el forward_list.
_Alloc	El objeto asignador almacenado que encapsula los detalles acerca de la asignación y desasignación de memoria forward_list.Este parámetro es opcional.El valor predeterminado es asignador <Type>.
_Count	El número de elementos de un forward_list.
_Val	El elemento para agregar a la forward_list.
_Right	La lista para incorporar a la forward_list.
_Pos	El iterador que indica una ubicación en la forward_list.
_First	El iterador que indica la ubicación de inicio para un intervalo de elementos de la forward_list.
_Last	El iterador que indica la ubicación final de un intervalo de elementos de la forward_list.
_Init	La lista de inicializadores
_List	Forward_list para combinar, empalmar o asignar desde.
_Comp	Función de comparación.

Comentarios

A forward_list objeto asigna y libera almacenamiento de información para la secuencia controla a través de un objeto almacenado de la clase Allocator que se basa en allocator Class (conocido comúnmente como std::allocator).Para obtener más información, vea Asignadores.Un objeto asignador debe tener la misma interfaz externa como un objeto de clase de plantilla allocator.

[!NOTA]

No se copia el objeto asignador almacenados cuando se asigna el objeto contenedor.

Los iteradores, punteros y referencias podrían no ser válidas cuando se borran los elementos de su secuencia controlada a través de forward_list.Las inserciones y empalmes realizan en la secuencia controlada a través de forward_list no invalidan los iteradores.

Pueden producirse las adiciones a la secuencia controlada por las llamadas a forward_list::insert_after, que es la única función de miembro que llama al constructor Type(const _Type&).forward_listes posible que también llamada se mueva constructores.Si dicha expresión produce una excepción, el objeto contenedor no inserta ningún elemento nuevo y vuelve a producir la excepción.Por lo tanto, un objeto de clase de plantilla forward_list se deja en un estado conocido cuando se producen dichas excepciones.

Constructores

forward_list

Construye un objeto de tipo forward_list.

Typedefs

allocator_type	Un tipo que representa la clase de asignador de un objeto de la lista hacia adelante.
const_iterator	Un tipo que proporciona un iterador constante de la lista hacia adelante.
const_pointer	Un tipo que proporciona un puntero a un const elemento de una lista de reenvío.
const_reference	Un tipo que proporciona una referencia constante a un elemento en la lista hacia adelante.
difference_type	Un tipo de entero con signo que se puede utilizar para representar el número de elementos de una lista de reenvío en un intervalo entre los elementos al que señala los iteradores.
Iterador	Un tipo que proporciona un iterador de la lista hacia adelante.
pointer	Un tipo que proporciona un puntero a un elemento en la lista hacia adelante.
Referencia .	Un tipo que proporciona una referencia a un elemento en la lista hacia adelante.
size_type	Un tipo que representa la distancia entre dos elementos sin signo.
value_type	Un tipo que representa el tipo de elemento almacenado en una lista de reenvío.

Funciones miembro

assign	Elimina los elementos de una lista de reenvío y copia un nuevo conjunto de elementos en una lista de reenvío de destino.
before_begin	Devuelve un iterador hacer frente a la posición antes del primer elemento de una lista de reenvío.
begin	Devuelve un iterador direccionamiento del primer elemento de una lista de reenvío.
cbefore_begin	Devuelve un iterador const hacer frente a la posición antes del primer elemento de una lista de reenvío.
cbegin	Devuelve un iterador const direccionamiento del primer elemento de una lista de reenvío.
cend	Devuelve un iterador const que se ocupa de la ubicación del éxito del último elemento de una lista de reenvío.
clear	Borra todos los elementos de una lista de reenvío.
emplace_after	Mover construye un nuevo elemento después de una posición especificada.
emplace_front	Agrega un elemento construido en su lugar al principio de la lista.
empty	Comprueba si una lista de reenvío está vacía.
end	Devuelve un iterador que se ocupa de la ubicación del éxito del último elemento de una lista de reenvío.
erase_after	Quita elementos de la lista directa después de una posición especificada.
front	Devuelve una referencia al primer elemento de una lista de reenvío.
get_allocator	Devuelve una copia del objeto asignador utilizado para construir una lista de reenvío.
insert_after	Agrega elementos a la lista directa después de una posición especificada.
max_size	Devuelve la longitud máxima de una lista de reenvío.
combinar	Quita los elementos de la lista de argumentos, inserta en la lista de reenvío de destino y ordena el conjunto nuevo, combinado de elementos en orden ascendente o en cualquier otro orden especificado.
pop_front	Elimina el elemento al principio de una lista de reenvío.
push_front	Agrega un elemento al principio de una lista de reenvío.
remove	Elimina los elementos en una lista de reenvío que coincide con un valor especificado.
remove_if	Elimina los elementos de una lista de reenvío para el que se satisface un predicado especificado.
resize	Especifica un tamaño nuevo para obtener una lista de reenvío.
inversa	Invierte el orden en que los elementos se suceden en una lista de reenvío.
sort	Organiza los elementos en orden ascendente o con un orden especificado por un predicado.
splice_after	Restitches vínculos entre los nodos.
swap	Intercambia los elementos de dos listas hacia adelante.
unique	Quita los elementos adyacentes que pasan una prueba especificada.

Operadores

operator=

Reemplaza los elementos de la lista hacia adelante con una copia de otra lista de reenvío.

Requisitos

Encabezado: <forward_list>

Espacio de nombres: std

Vea también

Referencia

<forward_list>

Otros recursos

miembros de <forward_list>

Compartir a través de