Classe front_insert_iterator

Descrive un adattatore dell'iteratore che soddisfa i requisiti dell'iteratore di output. Inserisce, anziché sovrascrivere, gli elementi nella parte anteriore di una sequenza. Fornisce quindi una semantica diversa dalla semantica di sovrascrittura fornita dagli iteratori dei contenitori di sequenze C++. Viene creato un modello della classe front_insert_iterator in base al tipo di contenitore.

Sintassi

template <class Container>
class front_insert_iterator;

Parametri

Contenitore
Tipo di contenitore nella cui parte iniziale devono essere inseriti gli elementi da un front_insert_iterator.

Osservazioni:

Il contenitore deve soddisfare i requisiti di una sequenza di inserimento all'inizio in cui è possibile inserire gli elementi all'inizio della sequenza in un tempo costante ammortizzato. I contenitori sequenziali della libreria standard C++ definiti dalla classe deque e dalla classe list forniscono la funzione membro push_front necessaria e soddisfano tali requisiti. Al contrario, i contenitori di sequenza definiti dalla classe vettoriale non soddisfano questi requisiti e non possono essere adattati per l'uso con front_insert_iterators. Un front_insert_iterator deve essere sempre inizializzato con il relativo contenitore.

Costruttori

Costruttore	Descrizione
front_insert_iterator	Crea un iteratore in grado di inserire elementi all'inizio di un oggetto contenitore specificato.

Typedef

Nome tipo	Descrizione
container_type	Tipo che rappresenta il contenitore in cui è necessario effettuare un inserimento all'inizio.
reference	Tipo che fornisce un riferimento a un elemento di una sequenza controllata dal contenitore associato.

Operatori

Operatore	Descrizione
operator*	Operatore di dereferenziazione usato per implementare l'espressione dell'iteratore di output * i = x per un inserimento all'inizio.
operator++	Incrementa front_insert_iterator alla posizione successiva in cui è possibile archiviare un valore.
operator=	Operatore di assegnazione usato per implementare l'espressione dell'iteratore di output * i = x per un inserimento all'inizio.

Requisiti

Intestazione: <iteratore>

Spazio dei nomi: std

front_insert_iterator::container_type

Tipo che rappresenta il contenitore in cui è necessario effettuare un inserimento all'inizio.

typedef Container container_type;

Osservazioni:

Il tipo è un sinonimo del parametro di modello Container.

Esempio

// 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

Crea un iteratore in grado di inserire elementi all'inizio di un oggetto contenitore specificato.

explicit front_insert_iterator(Container& _Cont);

Parametri

_Cont
Oggetto contenitore in cui front_insert_iterator deve inserire gli elementi.

Valore restituito

front_insert_iterator per l'oggetto contenitore di parametri.

Esempio

// 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::operator*

Dereferenzia l'iteratore di inserimento restituendo l'elemento a cui punta.

front_insert_iterator<Container>& operator*();

Valore restituito

La funzione membro restituisce il valore dell'elemento puntato.

Osservazioni:

Usato per implementare l'espressione dell'iteratore di output *Valore iter = . Se Iter è un iteratore che punta a un elemento in una sequenza, *Valore Iter = sostituisce tale elemento con valore e non modifica il numero totale di elementi nella sequenza.

Esempio

// 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::operator++

Incrementa back_insert_iterator alla posizione successiva in cui è possibile archiviare un valore.

front_insert_iterator<Container>& operator++();

front_insert_iterator<Container> operator++(int);

Valore restituito

front_insert_iterator che punta alla posizione successiva in cui può essere archiviato un valore.

Osservazioni:

Sia gli operatori di pre-incremento che quelli di post-incremento restituiscono lo stesso risultato.

Esempio

// 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=

Accoda (inserisce mediante push) un valore all'inizio del contenitore.

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

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

Parametri

val
Valore da assegnare al contenitore.

Valore restituito

Riferimento all'ultimo elemento inserito all'inizio del contenitore.

Osservazioni:

Il primo operatore membro valuta container.push_front( val) e quindi restituisce *this.

Il secondo operatore membro valuta

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

e quindi restituisce *this.

Esempio

// 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::reference

Tipo che fornisce un riferimento a un elemento di una sequenza controllata dal contenitore associato.

typedef typename Container::reference reference;

Esempio

// 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.
*/

Vedi anche

<iterator>
Thread Safety in the C++ Standard Library (Sicurezza dei thread nella libreria standard C++)
Informazioni di riferimento per la libreria standard C++