Classe forward_list

Descreve um objeto que controla uma sequência de elementos de tamanho variado. A sequência é armazenada como uma lista de nós vinculada exclusivamente, com cada um contendo um membro do tipo Type.

Sintaxe

template <class Type,
    class Allocator = allocator<Type>>
class forward_list

Parâmetros

Type
O tipo de dados do elemento a ser armazenado no forward_list.

Allocator
O objeto alocador armazenado que encapsula detalhes sobre a forward_list alocação e desalocação da memória. Esse parâmetro é opcional. O valor padrão é allocator<Type>.

Comentários

Um forward_list objeto aloca e libera o armazenamento para a sequência que controla por meio de um objeto armazenado de classe Allocator baseado em allocator Classe (comumente conhecido como std::allocator). Para obter mais informações, consulte o Alocadores. Um objeto alocador precisa ter a mesma interface externa que um objeto de tipo allocator.

Iteradores, ponteiros e referências podem se tornar inválidos quando elementos de sua sequência são apagados por meio de forward_list. Inserções e uniões executadas na sequência controlada por meio de forward_list não invalidam iteradores.

As adições à sequência controlada podem ocorrer por chamadas para forward_list::insert_after, que é a única função membro que chama o construtor Type(const T&). forward_list também pode chamar construtores de movimento. Se a expressão gerar uma exceção, o objeto de contêiner não insere novos elementos e gera a exceção novamente. Portanto, um objeto do tipo forward_list é deixado em um estado conhecido quando essas exceções ocorrem.

Membros

Construtores

Typedefs

Functions

Operadores

allocator_type

Um tipo que representa a classe de alocador para um objeto de lista de encaminhamento.

typedef Allocator allocator_type;

Comentários

allocator_type é um sinônimo do parâmetro de modelo Allocator.

assign

Apaga elementos de uma lista de encaminhamento e copia um novo conjunto de elementos para uma lista de encaminhamento de destino.

void assign(
    size_type Count,
    const Type& Val);

void assign(
    initializer_list<Type> IList);

template <class InputIterator>
void assign(InputIterator First, InputIterator Last);

Parâmetros

first
O início do intervalo de substituição.

last
O final do intervalo de substituição.

count
O número de elementos a serem atribuídos.

val
O valor a atribuir a cada elemento.

Type
O tipo do valor.

IList
A initializer_list cópia a ser copiada.

Comentários

Se for forward_list um tipo inteiro, a primeira função de membro se comportará da mesma forma assign((size_type)First, (Type)Last)que . Caso contrário, a primeira função membro substitui a sequência controlada por *this pela sequência [First, Last), que não deve se sobrepor à sequência controlada inicial.

A segunda função membro substitui a sequência controlada por *this por uma repetição de elementos Count de valor Val.

A terceira função membro copia os elementos do initializer_list .forward_list

before_begin

Retorna um iterador que trata da posição antes do primeiro elemento em uma lista de encaminhamento.

const_iterator before_begin() const;
iterator before_begin();

Valor de retorno

Um iterador de encaminhamento que aponta para o primeiro elemento da sequência (ou imediatamente antes do fim de uma sequência vazia).

begin

Retorna um iterador que trata do primeiro elemento em uma lista de encaminhamento.

const_iterator begin() const;
iterator begin();

Valor de retorno

Um iterador de encaminhamento que aponta para o primeiro elemento da sequência (ou imediatamente após o fim de uma sequência vazia).

cbefore_begin

Retorna um iterador const que trata da posição antes do primeiro elemento em uma lista de encaminhamento.

const_iterator cbefore_begin() const;

Valor de retorno

Um iterador de encaminhamento que aponta para o primeiro elemento da sequência (ou imediatamente antes do fim de uma sequência vazia).

cbegin

Retorna um iterador const que trata o primeiro elemento no intervalo.

const_iterator cbegin() const;

Valor de retorno

Um iterador de acesso por avanço const que aponta o primeiro elemento do intervalo ou o local logo após o fim de um intervalo vazio (para um intervalo vazio, cbegin() == cend()).

Comentários

Com o valor retornado de cbegin, os elementos no intervalo não podem ser modificados.

Você pode usar essa função membro no lugar da função membro begin(), de modo a garantir que o valor de retorno seja const_iterator. Normalmente, ela é usada com a palavra-chave de dedução de tipo auto, conforme mostrado no exemplo a seguir. No exemplo, considere Container como um contêiner modificável (não const) de qualquer tipo, que dá suporte para begin() e cbegin().

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();
// i2 is Container<T>::const_iterator

cend

Retorna um iterador const que trata o local logo após o último elemento em um intervalo.

const_iterator cend() const;

Valor de retorno

Um iterador de acesso por avanço que aponta para além do fim do intervalo.

Comentários

cend é usado para testar se um iterador passou do fim de seu intervalo.

Você pode usar essa função membro no lugar da função membro end(), de modo a garantir que o valor de retorno seja const_iterator. Normalmente, ela é usada com a palavra-chave de dedução de tipo auto, conforme mostrado no exemplo a seguir. No exemplo, considere Container como um contêiner modificável (não const) de qualquer tipo, que dá suporte para end() e cend().

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

O valor retornado por cend não deve ser desreferenciado.

clear

Apaga todos os elementos de uma lista de encaminhamento.

void clear();

Comentários

Essa função membro chama erase_after(before_begin(), end()).

const_iterator

Um tipo que fornece um iterador constante para a lista de encaminhamento.

typedef implementation-defined const_iterator;

Comentários

const_iterator descreve um objeto que pode servir como um iterador de encaminhamento constante para a sequência controlada. Ele é descrito aqui como sinônimo de um tipo definido pela implementação.

const_pointer

Um tipo que fornece um ponteiro para um elemento const em uma lista de encaminhamento.

typedef typename Allocator::const_pointer
    const_pointer;

const_reference

Um tipo que fornece uma referência constante a um elemento na lista de encaminhamento.

typedef typename Allocator::const_reference const_reference;

difference_type

Um tipo de inteiro com sinal que pode ser usado para representar o número de elementos de uma lista de encaminhamento em um intervalo entre os elementos apontados por iteradores.

typedef typename Allocator::difference_type difference_type;

Comentários

difference_type descreve um objeto que pode representar a diferença entre os endereços de dois elementos na sequência controlada.

emplace_after

Move constructos de um novo elemento após uma posição especificada.

template <class T>
iterator emplace_after(const_iterator Where, Type&& val);

Parâmetros

Where
A posição na lista de encaminhamento de destino em que o novo elemento é criado.

val
O argumento do construtor.

Valor de retorno

Um iterador que designa o elemento recém-inserido.

Comentários

Essa função membro insere um elemento com os argumentos val do construtor logo após o elemento apontado na Where sequência controlada. Caso contrário, seu comportamento é o mesmo forward_list::insert_afterque .

emplace_front

Adiciona um elemento construído no local ao início da lista.

template <class Type>
    void emplace_front(Type&& val);

Parâmetros

val
O elemento adicionado ao início da lista de encaminhamento.

Comentários

Essa função membro insere um elemento com os argumentos val do construtor no início da sequência controlada.

Se uma exceção for gerada, o contêiner permanecerá inalterado e a exceção será gerada novamente.

empty

Testa se uma lista de encaminhamento está vazia.

bool empty() const;

Valor de retorno

true se a lista de encaminhamento estiver vazia; caso contrário, false.

end

Retorna um iterador que trata do local após o último elemento em uma lista de encaminhamento.

const_iterator end() const;
iterator end();

Valor de retorno

Um iterador de encaminhamento que aponta para logo após o fim da sequência.

erase_after

Remove elementos da lista de encaminhamento depois de uma posição especificada.

iterator erase_after(const_iterator Where);
iterator erase_after(const_iterator first, const_iterator last);

Parâmetros

Where
A posição na lista de encaminhamento de destino em que o novo elemento é apagado.

first
O início do intervalo a ser apagado.

last
O final do intervalo a ser apagado.

Valor de retorno

Um iterador que designa o primeiro elemento que permanece além de qualquer elemento removido ou forward_list::end se nenhum elemento desse tipo existe.

Comentários

A primeira função membro remove o elemento da sequência controlada logo após Where.

A segunda função membro remove os elementos da sequência controlada no intervalo ( first, last) (nenhum ponto de extremidade está incluído).

Apagar elementos N causas chamadas de destruidor de N. A realocação ocorre, de modo que referências e iteradores tornam-se inválidos para os elementos apagados.

As funções membro nunca geram uma exceção.

forward_list

Constrói um objeto do tipo forward_list.

forward_list();
explicit forward_list(const Allocator& Al);
explicit forward_list(size_type Count);
forward_list(size_type Count, const Type& Val);
forward_list(size_type Count, const Type& Val, const Allocator& Al);
forward_list(const forward_list& Right);
forward_list(const forward_list& Right, const Allocator& Al);
forward_list(forward_list&& Right);
forward_list(forward_list&& Right, const Allocator& Al);
forward_list(initializer_list<Type> IList, const Alloc& Al);
template <class InputIterator>
forward_list(InputIterator First, InputIterator Last);
template <class InputIterator>
forward_list(InputIterator First, InputIterator Last, const Allocator& Al);

Parâmetros

Al
A classe de alocador a ser usada com esse objeto.

Count
O número de elementos na lista construída.

Val
O valor dos elementos na lista construída.

Right
A lista da qual a lista construída é uma cópia.

First
A posição do primeiro elemento no intervalo de elementos a serem copiados.

Last
A posição do primeiro elemento além do intervalo de elementos a serem copiados.

IList
A initializer_list cópia a ser copiada.

Comentários

Todos os construtores armazenam e allocator inicializam a sequência controlada. O objeto alocador é o argumento Al, se presente. Para o construtor de cópia, ele será right.get_allocator(). Caso contrário, é Allocator().

Os primeiros dois construtores especificam uma sequência controlada inicial vazia.

O terceiro construtor especifica uma repetição de Count elementos de valor Type().

O quarto e o quinto construtores especificam uma repetição de Count elementos de valor Val.

O sexto construtor especifica uma cópia da sequência controlada por Right. Se InputIterator for um tipo inteiro, os dois construtores seguintes especificam uma repetição de elementos (size_type)First de valor (Type)Last. Caso contrário, os dois construtores seguintes especificam a sequência [First, Last).

O nono e o décimo construtor são os mesmos que o sexto, mas com uma referência de rvalue.

O último construtor especifica a sequência controlada inicial com um objeto da classe initializer_list<Type>.

front

Retorna uma referência ao primeiro elemento em uma lista de encaminhamento.

reference front();
const_reference front() const;

Valor de retorno

Uma referência ao primeiro elemento da sequência controlada, que não pode ser vazio.

get_allocator

Retorna uma cópia do objeto alocador usado para construir uma lista de encaminhamento.

allocator_type get_allocator() const;

Valor de retorno

O objeto armazenado allocator .

insert_after

Adiciona elementos à lista de encaminhamento depois de uma posição especificada.

iterator insert_after(const_iterator Where, const Type& Val);
void insert_after(const_iterator Where, size_type Count, const Type& Val);
void insert_after(const iterator Where, initializer_list<Type> IList);
iterator insert_after(const_iterator Where, Type&& Val);
template <class InputIterator>
    void insert_after(const_iterator Where, InputIterator First, InputIterator Last);

Parâmetros

Where
A posição na lista de encaminhamento de destino em que o primeiro elemento é inserido.

Count
O número de elementos a serem inseridos.

First
O início do intervalo de inserção.

Last
O final do intervalo de inserção.

Val
O elemento adicionado à lista de encaminhamento.

IList
A initializer_list inserção a ser inserida.

Valor de retorno

Um iterador que designa o elemento recém-inserido (apenas a primeira e a última função membro).

Comentários

Cada uma das funções membro insere, logo após o elemento apontado na Where sequência controlada, uma sequência especificada pelos operandos restantes.

A primeira função membro insere um elemento que tem valor Val e retorna um iterador que designa o elemento recém-inserido.

A segunda função membro insere uma repetição de Count elementos de valor Val.

Se InputIterator for um tipo inteiro, a terceira função membro se comportará da mesma forma que insert(it, (size_type)First, (Type)Last). Caso contrário, inserirá a sequência [First, Last), que não pode se sobrepor à sequência controlada inicial.

A quarta função membro insere a sequência especificada por um objeto da classe initializer_list<Type>.

A última operação membro é a mesma que a primeira, mas com uma referência de rvalue.

Inserir elementos N causa chamadas de construtor de N. A realocação ocorre, mas nenhum iterador ou referência se torna inválida.

Se uma exceção for gerada durante a inserção de um ou mais elementos, o contêiner permanecerá inalterado e a exceção será gerada novamente.

iterator

Um tipo que fornece um iterador para a lista de encaminhamento.

typedef implementation-defined iterator;

Comentários

iterator descreve um objeto que pode servir como um iterador de encaminhamento para a sequência controlada. Ele é descrito aqui como sinônimo de um tipo definido pela implementação.

max_size

Retorna o tamanho máximo de uma lista de encaminhamento.

size_type max_size() const;

Valor de retorno

O tamanho da sequência mais longa que o objeto pode controlar.

merge

Combina duas sequências classificadas em uma única sequência classificada em tempo linear. Remove os elementos da lista de argumentos e os insere neste forward_list. As duas listas devem ser classificadas pelo objeto de função de comparação antes da chamada para merge. A lista combinada será classificada pelo objeto de função de comparação.

void merge(forward_list& right);
template <class Predicate>
    void merge(forward_list& right, Predicate comp);

Parâmetros

right
A lista de encaminhamento a ser mesclada.

comp
O objeto de função compare que é usado para classificar elementos.

Comentários

forward_list::merge remove os elementos do forward_listright, e os insere neste forward_list. As duas sequências devem ser ordenadas pelo mesmo predicado, descrito abaixo. A sequência combinada também é ordenada por esse objeto de função de comparação.

Para os iteradores Pi e Pj que designam elementos nas posições i e j, a primeira função membro impõe a ordem !(*Pj < *Pi) sempre que i < j. (Os elementos são classificados em ordem ascending.) A segunda função membro impõe a ordem ! comp(*Pj, *Pi) sempre que i < j.

Nenhum par de elementos na sequência controlada original é revertido na sequência controlada resultante. Se um par de elementos na sequência controlada resultante comparar igual (!(*Pi < *Pj) && !(*Pj < *Pi)), um elemento da sequência controlada original aparecerá antes de um elemento da sequência controlada por right.

Uma exceção ocorre somente se comp gerar uma exceção. Nesse caso, a sequência controlada será deixada em uma ordem não especificada e a exceção será gerada novamente.

operator=

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

forward_list& operator=(const forward_list& right);
forward_list& operator=(initializer_list<Type> IList);
forward_list& operator=(forward_list&& right);

Parâmetros

right
A lista de encaminhamento que está sendo copiada para a lista de encaminhamento.

IList
Uma lista de inicializadores entre chaves, que se comporta exatamente como uma sequência de elementos do tipo Type.

Comentários

O primeiro operador membro substitui a sequência controlada por uma cópia da sequência controlada por right.

O segundo operador membro substitui a sequência controlada de um objeto da classe initializer_list<Type>.

O terceiro operador membro é o mesmo que a primeiro, mas com uma referência de rvalue.

pointer

Um tipo que fornece um ponteiro para um elemento na lista de encaminhamento.

typedef typename Allocator::pointer pointer;

pop_front

Exclui o elemento no início de uma lista de encaminhamento.

void pop_front();

Comentários

O primeiro elemento da lista de encaminhamento não pode ser vazio.

A função membro nunca gera uma exceção.

push_front

Adiciona um elemento as início de uma lista de encaminhamento.

void push_front(const Type& val);
void push_front(Type&& val);

Parâmetros

val
O elemento adicionado ao início da lista de encaminhamento.

Comentários

Se uma exceção for gerada, o contêiner permanecerá inalterado e a exceção será gerada novamente.

reference

Um tipo que fornece uma referência para um elemento na lista de encaminhamento.

typedef typename Allocator::reference reference;

remove

Apaga elementos em uma lista de encaminhamento que correspondem a um valor especificado.

void remove(const Type& val);

Parâmetros

val
O valor que, se mantido por um elemento, resultará na remoção de tal elemento da lista.

Comentários

A função membro remove da sequência controlada todos os elementos, designados pelo iterador P, para os quais *P == val.

A função membro nunca gera uma exceção.

remove_if

Apaga os elementos da lista de encaminhamento para os quais um predicado especificado foi atendido.

template <class Predicate>
    void remove_if(Predicate pred);

Parâmetros

pred
O predicado unário que, se atendido por um elemento, resultará na exclusão de tal elemento da lista.

Comentários

A função membro remove da sequência controlada todos os elementos designados pelo iterador P para os quais pred(*P) é verdadeiro.

Uma exceção ocorre somente se pred gerar uma exceção. Nesse caso, a sequência controlada é deixada em um estado não especificado e a exceção é gerada novamente.

resize

Especifica um novo tamanho para uma lista de encaminhamento.

void resize(size_type _Newsize);
void resize(size_type _Newsize, const Type& val);

Parâmetros

_Newsize
O número de elementos na lista de encaminhamento redimensionada.

val
O valor a ser usado para preenchimento.

Comentários

As funções de membro garantem que o número de elementos na lista de agora em diante seja _Newsize. Se precisar tornar a sequência controlada mais longa, a primeira função membro acrescentará elementos com valor Type(), enquanto a segunda função membro acrescenta elementos com valor val. Para tornar a sequência controlada mais curta, as duas funções membro efetivamente chamam erase_after(begin() + _Newsize - 1, end()).

reverse

Reverte a ordem na qual os elementos ocorrem em uma lista de encaminhamento.

void reverse();

size_type

Um tipo que representa a distância sem sinal entre dois elementos.

typedef typename Allocator::size_type size_type;

Comentários

O tipo inteiro sem sinal descreve um objeto que pode representar o tamanho de qualquer sequência controlada.

sort

Organiza os elementos em ordem crescente ou em uma ordem especificada por um predicado.

void sort();
template <class Predicate>
void sort(Predicate pred);

Parâmetros

pred
O predicado de ordenação.

Comentários

As duas funções membro ordenam os elementos na sequência controlada por um predicado, descrito abaixo.

Para os iteradores Pi e Pj que designam elementos nas posições i e j, a primeira função membro impõe a ordem !(*Pj < *Pi) sempre que i < j. (Os elementos são classificados em ordem ascending.) A função membro de modelo impõe a ordem ! pred(*Pj, *Pi) sempre que i < j. Nenhum par ordenado de elementos na sequência controlada original é revertido na sequência controlada resultante. (A classificação é estável).

Uma exceção ocorre somente se pred gerar uma exceção. Nesse caso, a sequência controlada será deixada em uma ordem não especificada e a exceção será gerada novamente.

splice_after

Remove elementos de uma origem forward_list e os insere em um destino forward_list.

// insert the entire source forward_list
void splice_after(const_iterator Where, forward_list& Source);
void splice_after(const_iterator Where, forward_list&& Source);

// insert one element of the source forward_list
void splice_after(const_iterator Where, forward_list& Source, const_iterator Iter);
void splice_after(const_iterator Where, forward_list&& Source, const_iterator Iter);

// insert a range of elements from the source forward_list
void splice_after(
    const_iterator Where,
    forward_list& Source,
    const_iterator First,
    const_iterator Last);

void splice_after(
    const_iterator Where,
    forward_list&& Source,
    const_iterator First,
    const_iterator Last);

Parâmetros

Where
A posição no destino forward_list após a qual inserir.

Source
A origem forward_list que deve ser inserida no destino forward_list.

Iter
O elemento a ser inserido da origem forward_list.

First
O primeiro elemento no intervalo a ser inserido da origem forward_list.

Last
A primeira posição além do intervalo a ser inserido da origem forward_list.

Comentários

O primeiro par de funções de membro insere a sequência controlada logo Source após o elemento na sequência controlada apontada por Where. Ele também remove todos os elementos de Source. (&Source não deve ser igual a this.)

O segundo par de funções de membro remove o elemento logo após Iter na sequência controlada Source e insere-o logo após o elemento na sequência controlada apontada por Where. (Se Where == Iter || Where == ++Iter, nenhuma alteração ocorrerá.)

O terceiro par de funções de membro (splice ranged) insere o subrange designado pela (First, Last) sequência controlada logo Source após o elemento na sequência controlada apontada por Where. Ele também remove o subconjunto original da sequência controlada por Source. (Se &Source == this, o intervalo (First, Last) não deve incluir o elemento apontado por Where.)

Se a junção de intervalo inserir elementos N e &Source != thisum objeto de classe iterator for incrementado N em tempos.

Nenhum iterador, ponteiro ou referência que designa elementos unidos se torna inválido.

Exemplo

// forward_list_splice_after.cpp
// compile with: /EHsc /W4
#include <forward_list>
#include <iostream>

using namespace std;

template <typename S> void print(const S& s) {
    for (const auto& p : s) {
        cout << "(" << p << ") ";
    }

    cout << endl;
}

int main()
{
    forward_list<int> c1{ 10, 11 };
    forward_list<int> c2{ 20, 21, 22 };
    forward_list<int> c3{ 30, 31 };
    forward_list<int> c4{ 40, 41, 42, 43 };

    forward_list<int>::iterator where_iter;
    forward_list<int>::iterator first_iter;
    forward_list<int>::iterator last_iter;

    cout << "Beginning state of lists:" << endl;
    cout << "c1 = ";
    print(c1);
    cout << "c2 = ";
    print(c2);
    cout << "c3 = ";
    print(c3);
    cout << "c4 = ";
    print(c4);

    where_iter = c2.begin();
    ++where_iter; // start at second element
    c2.splice_after(where_iter, c1);
    cout << "After splicing c1 into c2:" << endl;
    cout << "c1 = ";
    print(c1);
    cout << "c2 = ";
    print(c2);

    first_iter = c3.begin();
    c2.splice_after(where_iter, c3, first_iter);
    cout << "After splicing the first element of c3 into c2:" << endl;
    cout << "c3 = ";
    print(c3);
    cout << "c2 = ";
    print(c2);

    first_iter = c4.begin();
    last_iter = c4.end();
    // set up to get the middle elements
    ++first_iter;
    c2.splice_after(where_iter, c4, first_iter, last_iter);
    cout << "After splicing a range of c4 into c2:" << endl;
    cout << "c4 = ";
    print(c4);
    cout << "c2 = ";
    print(c2);
}

Beginning state of lists:c1 = (10) (11)c2 = (20) (21) (22)c3 = (30) (31)c4 = (40) (41) (42) (43)After splicing c1 into c2:c1 =c2 = (20) (21) (10) (11) (22)After splicing the first element of c3 into c2:c3 = (30)c2 = (20) (21) (31) (10) (11) (22)After splicing a range of c4 into c2:c4 = (40) (41)c2 = (20) (21) (42) (43) (31) (10) (11) (22)

swap

Troca os elementos de duas listas de encaminhamento.

void swap(forward_list& right);

Parâmetros

right
A lista de encaminhamento que fornece os elementos a serem trocados.

Comentários

A função membro troca as sequências controladas entre *this e right. Se get_allocator() == right.get_allocator(), ela faz isso em tempo constante, não gera exceções e não invalida referências, ponteiros ou iteradores que designam elementos nas duas sequências controlados. Caso contrário, ela executa atribuições de elemento e chamadas ao construtor proporcionais ao número de elementos nas duas sequências controladas.

unique

Elimina todos, exceto pelo primeiro elemento de cada grupo consecutivo de elementos iguais.

void unique();
template <class BinaryPredicate>
void unique(BinaryPredicate comp);

Parâmetros

comp
O predicado binário usado para comparar elementos sucessivos.

Comentários

Mantém o primeiro de cada elemento exclusivo e remove o restante. Os elementos devem ser classificados para que elementos do mesmo valor fiquem adjacentes na lista.

A primeira função membro remove da sequência controlada todos os elementos que, na comparação, são iguais ao elemento anterior. Para os iteradores Pi e Pj que designam elementos nas posições i e j, a segunda função membro remove todos os elementos para os quais i + 1 == j && comp(*Pi, *Pj).

Para uma sequência controlada de tamanho N (> 0), o predicado comp(*Pi, *Pj) é avaliado N - 1 vezes.

Uma exceção ocorre somente se comp gerar uma exceção. Nesse caso, a sequência controlada é deixada em um estado não especificado e a exceção é gerada novamente.

value_type

Um tipo que representa o tipo de elemento armazenado em uma lista de encaminhamento.

typedef typename Allocator::value_type value_type;

Comentários

O tipo é um sinônimo do parâmetro de modeloType.