front_insert_iterator-Klasse

Beschreibt einen Iteratoradapter, der den Anforderungen eines Ausgabeiterators entspricht. Es fügt Elemente anstelle von Überschreibungen in die Vorderseite einer Sequenz ein. Daher stellt sie Semantik bereit, die sich von der überschreibenden Semantik unterscheiden, die von den Iteratoren der C++-Sequenzcontainer bereitgestellt wird. Die front_insert_iterator-Klasse ist für den Typ des Containers vorlagenbasiert.

Syntax

template <class Container>
class front_insert_iterator;

Parameter

Container
Der Typ des Containers, an dessen Anfang Elemente von einem front_insert_iterator eingefügt werden sollen.

Hinweise

Der Container muss den Anforderungen einer Sequenz zum Einfügen am Anfang entsprechen, in der es möglich ist, die Elemente am Anfang der Sequenz in amortisierter konstanter Zeit einzufügen. Die Sequenzcontainer der C++-Standardbibliothek, die durch die deque-Klasse und die list-Klasse definiert werden, stellen die erforderliche push_front-Memberfunktion bereit und erfüllen diese Anforderungen. Im Gegensatz dazu erfüllen sequenzielle Container, die von der Vektorklasse definiert sind, diese Anforderungen nicht und können nicht an die Verwendung mit front_insert_iteratorden Vektoren angepasst werden. Ein front_insert_iterator muss immer mit seinem Container initialisiert werden.

Konstruktoren

TypeDefs

Operatoren

Anforderungen

Kopfzeile: <Iterator>

Namespace: std

front_insert_iterator::container_type

Ein Typ, der den Container darstellt, in dem eine Einfügung am Anfang vorgenommen werden soll.

typedef Container container_type;

Hinweise

Der Typ ist synonym mit dem Vorlagenparameter Container.

Beispiel

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

Damit wird ein Iterator erstellt, mit dem Elemente an den Anfang eines bestimmten Containerobjekts eingefügt werden können.

explicit front_insert_iterator(Container& _Cont);

Parameter

_Cont
Das Containerobjekt, in das front_insert_iterator Elemente einfügen soll

Rückgabewert

Ein front_insert_iterator für das Parametercontainerobjekt

Beispiel

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

Dereferenziert den Iterator zum Einfügen und gibt das Element zurück, das es adressiert

front_insert_iterator<Container>& operator*();

Rückgabewert

Die Memberfunktion gibt den Wert des adressierten Elements zurück

Hinweise

Wird verwendet, um den Ausgabe-Iteratorausdruck *Iter-Wert = zu implementieren. Wenn Iter es sich um einen Iterator handelt, der ein Element in einer Sequenz adressiert, ersetzt *Iter-Wert = dieses Element durch einen Wert und ändert nicht die Gesamtanzahl der Elemente in der Sequenz.

Beispiel

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

Inkrementiert back_insert_iterator zum folgenden Speicherort, an dem ein Wert gespeichert werden kann.

front_insert_iterator<Container>& operator++();

front_insert_iterator<Container> operator++(int);

Rückgabewert

Ein front_insert_iterator, der den nächsten Speicherort adressiert, an dem ein Wert gespeichert werden kann

Hinweise

Sowohl der Prä- als auch der Postinkrement-Operator geben das gleichen Ergebnis zurück.

Beispiel

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

Fügt einen Wert (per Push) am Anfang des Containers an

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

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

Parameter

val
Der Wert, der dem Container zugewiesen werden soll

Rückgabewert

Ein Verweis auf das letzte, am Anfang des Containers eingefügte Element

Hinweise

Der erster Memberoperator wertet container.push_front( val) aus und gibt *this zurück.

Der zweite Memberoperator wertet Folgendes aus:

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

danach gibt er *this zurück.

Beispiel

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

Ein Typ, der einen Verweis auf ein Element in einer Sequenz enthält, die durch den zugehörigen Container gesteuert wird.

typedef typename Container::reference reference;

Beispiel

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

Siehe auch

<iterator>
Threadsicherheit in der C++-Standardbibliothek
C++-Standardbibliotheksreferenz