forward_list Classe

Descreve um objeto que controla uma sequência de elementos de comprimento variável. A sequência é armazenada como uma lista de nós vinculados isoladamente, 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 alocação e desalocação forward_list de memória. Este parâmetro é opcional. O valor padrão é alocator<Type>.

Observações

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

Iteradores, ponteiros e referências podem se tornar inválidos quando elementos de sua sequência controlada são apagados através forward_listdo . Inserções e emendas realizadas na sequência controlada através forward_list não invalidam iteradores.

Adições à sequência controlada podem ocorrer por chamadas para forward_list::insert_after, que é a única função de membro que chama o construtor Type(const T&). forward_list também pode chamar construtores move. Se essa expressão lançar uma exceção, o objeto container não insere novos elementos e relançará a exceção. Assim, um objeto do tipo forward_list é deixado em um estado conhecido quando tais exceções ocorrem.

Membros

Construtores

Typedefs (definições de tipos)

Funções

Operadores

allocator_type

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

typedef Allocator allocator_type;

Observações

allocator_type é 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 da gama de substituição.

last
O fim da gama de substituição.

count
O número de elementos a atribuir.

val
O valor a ser atribuído a cada elemento.

Type
O tipo do valor.

IList
O initializer_list para copiar.

Observações

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

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

A função de terceiro membro copia os elementos do para o initializer_listforward_list.

before_begin

Retorna um iterador abordando a posição antes do primeiro elemento em uma lista de encaminhamento.

const_iterator before_begin() const;
iterator before_begin();

Valor de retorno

Um iterador avançado que aponta imediatamente antes do primeiro elemento da sequência (ou imediatamente antes do final de uma sequência vazia).

begin

Retorna um iterador endereçando o primeiro elemento em uma lista de encaminhamento.

const_iterator begin() const;
iterator begin();

Valor de retorno

Um iterador avançado que aponta para o primeiro elemento da sequência (ou logo após o final de uma sequência vazia).

cbefore_begin

Retorna um iterador const abordando a posição antes do primeiro elemento em uma lista de encaminhamento.

const_iterator cbefore_begin() const;

Valor de retorno

Um iterador avançado que aponta imediatamente antes do primeiro elemento da sequência (ou imediatamente antes do final de uma sequência vazia).

cbegin

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

const_iterator cbegin() const;

Valor de retorno

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

Observações

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

Você pode usar essa função de membro no lugar da função de membro begin() para garantir que o valor de retorno seja const_iterator. Normalmente, ele é usado com a palavra-chave de dedução de tipo auto, conforme mostrado no exemplo a seguir. No exemplo, considere Container como um recipiente modificável (não const) de qualquer tipo que suporte 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 aborda o local logo após o último elemento de um intervalo.

const_iterator cend() const;

Valor de retorno

Um iterador de acesso direto que aponta para além do final do intervalo.

Observações

cend é usado para testar se um iterador passou no final de seu intervalo.

Você pode usar essa função de membro no lugar da função de membro end() para garantir que o valor de retorno seja const_iterator. Normalmente, ele é usado com a palavra-chave de dedução de tipo auto, conforme mostrado no exemplo a seguir. No exemplo, considere Container como um recipiente modificável (não const) de qualquer tipo que suporte 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();

Observações

Esta função de 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;

Observações

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

const_pointer

Um tipo que fornece um ponteiro para um const elemento 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 assinado que pode ser usado para representar o número de elementos de uma lista direta em um intervalo entre elementos apontados por iteradores.

typedef typename Allocator::difference_type difference_type;

Observações

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

emplace_after

Move constrói 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 onde o novo elemento é construído.

val
O argumento do construtor.

Valor de retorno

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

Observações

Esta função de membro insere um elemento com os argumentos val do construtor logo após o elemento apontado por Where na sequência controlada. Seu comportamento é o mesmo que forward_list::insert_after.

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.

Observações

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

Se uma exceção for lançada, o contêiner será deixado inalterado e a exceção será relançada.

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 aborda o local que sucede o último elemento em uma lista de encaminhamento.

const_iterator end() const;
iterator end();

Valor de retorno

Um iterador avançado que aponta para além do final da sequência.

erase_after

Remove elementos da lista de encaminhamento após 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 onde o elemento é apagado.

first
O início do intervalo para apagar.

last
O fim do intervalo para apagar.

Valor de retorno

Um iterador que designa o primeiro elemento remanescente além de quaisquer elementos removidos, ou forward_list::end se tal elemento não existir.

Observações

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

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

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

As funções de membro nunca lançam 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 deve ser uma cópia.

First
A posição do primeiro elemento na gama de elementos a serem copiados.

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

IList
O initializer_list para copiar.

Observações

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

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

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

O quarto e quinto construtores especificam uma repetição de elementos de Count 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 (size_type)First elementos de valor (Type)Last. Caso contrário, os próximos dois construtores especificam a sequência [First, Last).

O nono e décimo construtores 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 de classe initializer_list<Type>.

front

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

reference front();
const_reference front() const;

Valor de retorno

Uma referência ao primeiro elemento da sequência controlada, que deve não estar 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 após 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 onde o primeiro elemento é inserido.

Count
O número de elementos a inserir.

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
O initializer_list a inserir.

Valor de retorno

Um iterador que designa o elemento recém-inserido (apenas funções de primeiro e último membro).

Observações

Cada uma das funções de membro insere — logo após o elemento apontado pela Where sequência controlada — uma sequência que é especificada pelos operandos restantes.

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

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

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

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

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

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

Se uma exceção for lançada durante a inserção de um ou mais elementos, o contêiner será deixado inalterado e a exceção será relançada.

iterator

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

typedef implementation-defined iterator;

Observações

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

max_size

Devolve o comprimento máximo de uma lista de encaminhamentos.

size_type max_size() const;

Valor de retorno

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

merge

Combina duas sequências ordenadas numa única sequência ordenada em tempo linear. Remove os elementos da lista de argumentos e os insere neste forward_list. As duas listas devem ser classificadas pelo mesmo objeto de função de comparação antes da chamada para merge. A lista combinada será classificada por esse 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 partir da qual mesclar.

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

Observações

forward_list::merge remove os elementos do forward_listright, e os insere neste forward_list. Ambas as 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 elementos de designação em posições i e j, a função de primeiro membro impõe a ordem !(*Pj < *Pi) sempre que i < j. (Os elementos são ordenados por ascending ordem.) A função de segundo 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 aparece antes de um elemento da sequência controlada por right.

Uma exceção ocorre somente se comp lançar uma exceção. Nesse caso, a sequência controlada é deixada em ordem não especificada e a exceção é relançada.

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 como uma sequência de elementos do tipo Type.

Observações

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 de classe initializer_list<Type>.

O terceiro operador membro é o mesmo que o 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();

Observações

O primeiro elemento da lista de encaminhamento deve não estar vazio.

A função de membro nunca lança uma exceção.

push_front

Adiciona um elemento ao 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.

Observações

Se uma exceção for lançada, o contêiner será deixado inalterado e a exceção será relançada.

reference

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

typedef typename Allocator::reference reference;

remove

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

void remove(const Type& val);

Parâmetros

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

Observações

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

A função de membro nunca lança uma exceção.

remove_if

Apaga elementos de uma lista de encaminhamento para os quais um predicado especificado é satisfeito.

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

Parâmetros

pred
O predicado unário que, se satisfeito por um elemento, resulta na supressão desse elemento da lista.

Observações

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

Uma exceção ocorre somente se pred lançar uma exceção. Nesse caso, a sequência controlada é deixada em um estado não especificado e a exceção é relançada.

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.

Observações

As funções de membro garantem que o número de elementos na lista doravante é _Newsize. Se tiver de tornar a sequência controlada mais longa, a primeira função de membro acrescenta elementos com valor Type(), enquanto a função de segundo membro acrescenta elementos com valor val. Para tornar a sequência controlada mais curta, ambas as funções de membro efetivamente chamam erase_after(begin() + _Newsize - 1, end()).

reverse

Inverte a ordem em que os elementos ocorrem em uma lista de encaminhamento.

void reverse();

size_type

Um tipo que representa a distância não assinada entre dois elementos.

typedef typename Allocator::size_type size_type;

Observações

O tipo inteiro não assinado descreve um objeto que pode representar o comprimento de qualquer sequência controlada.

sort

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

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

Parâmetros

pred
O predicado de ordenação.

Observações

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

Para os iteradores Pi e Pj elementos de designação em posições i e j, a função de primeiro membro impõe a ordem !(*Pj < *Pi) sempre que i < j. (Os elementos são ordenados por ascending ordem.) A função de modelo de membro 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 lançar uma exceção. Nesse caso, a sequência controlada é deixada em ordem não especificada e a exceção é relançada.

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 fonte forward_list que deve ser inserida no destino forward_list.

Iter
O elemento a ser inserido a partir da fonte forward_list.

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

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

Observações

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

O segundo par de funções de membro remove o elemento logo depois Iter na sequência controlada por Source e o insere 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 (emenda variada) insere o subintervalo designado por (First, Last) a partir da sequência controlada por Source logo após o elemento na sequência controlada apontada por Where. Ele também remove o subintervalo original da sequência controlada pelo Source. (Se &Source == this, o intervalo (First, Last) não deve incluir o elemento apontado por Where.)

Se a emenda variada insere N elementos e &Source != this, um objeto de classe iterator é incrementado N vezes.

Nenhum iterador, ponteiro ou referência que designe elementos emendados 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 previsionais.

void swap(forward_list& right);

Parâmetros

right
A lista previsional com os elementos a trocar.

Observações

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

unique

Elimina todos, exceto o primeiro elemento, de todos os grupos consecutivos de elementos iguais.

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

Parâmetros

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

Observações

Mantém o primeiro de cada elemento único e remove o resto. Os elementos devem ser classificados de modo que os elementos de igual valor sejam adjacentes na lista.

A primeira função de membro remove da sequência controlada todos os elementos que se comparam iguais ao seu elemento anterior. Para os iteradores Pi e Pj elementos de designação em posições i e j, a função de segundo membro remove todos os elementos para os quais i + 1 == j && comp(*Pi, *Pj).

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

Uma exceção ocorre somente se comp lançar uma exceção. Nesse caso, a sequência controlada é deixada em um estado não especificado e a exceção é relançada.

value_type

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

typedef typename Allocator::value_type value_type;

Observações

O tipo é um sinônimo para o parâmetro de modelo Type.