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++
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per