Classe front_insert_iterator

Descreve um adaptador de iterador que atende aos requisitos de um iterador de saída. Ela insere, em vez de substituir, elementos na frente de uma sequência. Além disso, fornece semânticas diferentes da semântica de substituição fornecida pelos iteradores dos contêineres de sequência do C++. A classe front_insert_iterator é modelada no tipo do contêiner.

Sintaxe

template <class Container>
class front_insert_iterator;

Parâmetros

Contêiner
O tipo de contêiner na parte da frente dos elementos a serem inseridos por um front_insert_iterator.

Comentários

O contêiner deve atender aos requisitos de uma sequência de inserção anterior em que é possível inserir elementos no início da sequência em tempo constante amortizado. Os contêineres de sequência da Biblioteca Padrão C++ definidos pela classe deque e pela classe list fornecem a função membro push_front necessária e atendem a esses requisitos. Por outro lado, contêineres de sequência definidos pela classe vector não atendem a esses requisitos e não podem ser adaptados para uso com front_insert_iterators. Um front_insert_iterator sempre deve ser inicializado com seu contêiner.

Construtores

Construtor	Descrição
front_insert_iterator	Cria um iterador que pode inserir elementos na frente de um objeto de contêiner especificado.

Typedefs

Nome do tipo	Descrição
container_type	Um tipo que representa o contêiner no qual uma inserção anterior deve ser feita.
referência	Um tipo que fornece uma referência a um elemento em uma sequência controlada pelo contêiner associado.

Operadores

Operador	Descrição
operator*	Operador de cancelamento de referência usado para implementar a expressão do iterador de saída * i = x para uma inserção anterior.
operador++	Incrementa o front_insert_iterator para o próximo local no qual um valor pode ser armazenado.
operator=	Operador de atribuição usado para implementar a expressão do iterador de saída * i = x para uma inserção anterior.

Requisitos

Cabeçalho: <iterator>

Namespace: std

front_insert_iterator::container_type

Um tipo que representa o contêiner no qual uma inserção anterior deve ser feita.

typedef Container container_type;

Comentários

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

Exemplo

// front_insert_iterator_container_type.cpp
// compile with: /EHsc
#include <iterator>
#include <list>
#include <iostream>

int main( )
{
   using namespace std;

   list<int> L1;
   front_insert_iterator<list<int> >::container_type L2 = L1;
   front_inserter ( L2 ) = 20;
   front_inserter ( L2 ) = 10;
   front_inserter ( L2 ) = 40;

   list <int>::iterator vIter;
   cout << "The list L2 is: ( ";
   for ( vIter = L2.begin ( ) ; vIter != L2.end ( ); vIter++)
      cout << *vIter << " ";
   cout << ")." << endl;
}
/* Output:
The list L2 is: ( 40 10 20 ).
*/

front_insert_iterator::front_insert_iterator

Cria um iterador que pode inserir elementos na frente de um objeto de contêiner especificado.

explicit front_insert_iterator(Container& _Cont);

Parâmetros

_Cont
O objeto de contêiner no qual o front_insert_iterator deve inserir elementos.

Valor de retorno

Um front_insert_iterator para o objeto de contêiner do parâmetro.

Exemplo

// front_insert_iterator_front_insert_iterator.cpp
// compile with: /EHsc
#include <iterator>
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   int i;
   list <int>::iterator L_Iter;

   list<int> L;
   for (i = -1 ; i < 9 ; ++i )
   {
      L.push_back ( 2 * i );
   }

   cout << "The list L is:\n ( ";
   for ( L_Iter = L.begin( ) ; L_Iter != L.end( ); L_Iter++)
      cout << *L_Iter << " ";
   cout << ")." << endl;

   // Using the member function to insert an element
   front_inserter ( L ) = 20;

   // Alternatively, one may use the template function
   front_insert_iterator< list < int> > Iter(L);
*Iter = 30;

   cout << "After the front insertions, the list L is:\n ( ";
   for ( L_Iter = L.begin( ) ; L_Iter != L.end( ); L_Iter++)
      cout << *L_Iter << " ";
   cout << ")." << endl;
}
/* Output:
The list L is:
( -2 0 2 4 6 8 10 12 14 16 ).
After the front insertions, the list L is:
( 30 20 -2 0 2 4 6 8 10 12 14 16 ).
*/

front_insert_iterator::operador*

Cancela a referência do iterador de inserção, retornando o elemento que é seu alvo.

front_insert_iterator<Container>& operator*();

Valor de retorno

A função membro retorna o valor do elemento de destino.

Comentários

Usado para implementar a expressão do iterador de saída *Iter = valor. Se Iter for um iterador que trata de um elemento em uma sequência, *Iter = valor substituirá esse elemento pelo valor e não alterará o número total de elementos na sequência.

Exemplo

// front_insert_iterator_deref.cpp
// compile with: /EHsc
#include <iterator>
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   int i;
   list <int>::iterator L_Iter;

   list<int> L;
   for ( i = -1 ; i < 9 ; ++i )
   {
      L.push_back ( 2 * i );
   }

   cout << "The list L is:\n ( ";
   for ( L_Iter = L.begin( ) ; L_Iter != L.end( ); L_Iter++)
      cout << *L_Iter << " ";
   cout << ")." << endl;

   front_insert_iterator< list < int> > Iter(L);
*Iter = 20;

   // Alternatively, you may use
   front_inserter ( L ) = 30;

   cout << "After the front insertions, the list L is:\n ( ";
   for ( L_Iter = L.begin( ) ; L_Iter != L.end( ); L_Iter++)
      cout << *L_Iter << " ";
   cout << ")." << endl;
}
/* Output:
The list L is:
( -2 0 2 4 6 8 10 12 14 16 ).
After the front insertions, the list L is:
( 30 20 -2 0 2 4 6 8 10 12 14 16 ).
*/

front_insert_iterator::operador++

Incrementa o back_insert_iterator para o próximo local no qual um valor pode ser armazenado.

front_insert_iterator<Container>& operator++();

front_insert_iterator<Container> operator++(int);

Valor de retorno

Um front_insert_iterator que trata do próximo local no qual um valor pode ser armazenado.

Comentários

Os operadores pré-incremento e pós-incremento retornam o mesmo resultado.

Exemplo

// front_insert_iterator_op_incre.cpp
// compile with: /EHsc
#include <iterator>
#include <list>
#include <iostream>

int main( )
{
   using namespace std;

   list<int> L1;
   front_insert_iterator<list<int> > iter ( L1 );
*iter = 10;
   iter++;
*iter = 20;
   iter++;
*iter = 30;
   iter++;

   list <int>::iterator vIter;
   cout << "The list L1 is: ( ";
   for ( vIter = L1.begin ( ) ; vIter != L1.end ( ); vIter++ )
      cout << *vIter << " ";
   cout << ")." << endl;
}
/* Output:
The list L1 is: ( 30 20 10 ).
*/

front_insert_iterator::operator=

Acrescenta (envia por push) um valor à frente do contêiner.

front_insert_iterator<Container>& operator=(typename Container::const_reference val);

front_insert_iterator<Container>& operator=(typename Container::value_type&& val);

Parâmetros

val
O valor a ser atribuído ao contêiner.

Valor de retorno

Uma referência ao último elemento inserido na frente do contêiner.

Comentários

O primeiro operador membro avalia container.push_front( val) e retorna *this.

O segundo operador membro avalia

container->push_front((typename Container::value_type&&) val),

em seguida, retorna *this.

Exemplo

// front_insert_iterator_op_assign.cpp
// compile with: /EHsc
#include <iterator>
#include <list>
#include <iostream>

int main( )
{
   using namespace std;

   list<int> L1;
   front_insert_iterator<list<int> > iter ( L1 );
*iter = 10;
   iter++;
*iter = 20;
   iter++;
*iter = 30;
   iter++;

   list <int>::iterator vIter;
   cout << "The list L1 is: ( ";
   for ( vIter = L1.begin ( ) ; vIter != L1.end ( ); vIter++ )
      cout << *vIter << " ";
   cout << ")." << endl;
}
/* Output:
The list L1 is: ( 30 20 10 ).
*/

front_insert_iterator::Referência

Um tipo que fornece uma referência a um elemento em uma sequência controlada pelo contêiner associado.

typedef typename Container::reference reference;

Exemplo

// front_insert_iterator_reference.cpp
// compile with: /EHsc
#include <iterator>
#include <list>
#include <iostream>

int main( )
{
   using namespace std;

   list<int> L;
   front_insert_iterator<list<int> > fiivIter( L );
*fiivIter = 10;
*fiivIter = 20;
*fiivIter = 30;

   list<int>::iterator LIter;
   cout << "The list L is: ( ";
   for ( LIter = L.begin ( ) ; LIter != L.end ( ); LIter++)
      cout << *LIter << " ";
   cout << ")." << endl;

   front_insert_iterator<list<int> >::reference
        RefFirst = *(L.begin ( ));
   cout << "The first element in the list L is: "
        << RefFirst << "." << endl;
}
/* Output:
The list L is: ( 30 20 10 ).
The first element in the list L is: 30.
*/

Confira também

<iterator>
Acesso Thread-Safe na Biblioteca Padrão C++
Referência da biblioteca padrão C++