insert_iterator-Klasse

Beschreibt einen Iteratoradapter, der den Anforderungen eines Ausgabeiterators entspricht. Es fügt elemente in eine Sequenz ein, anstatt elemente zu überschreiben. Sie stellt somit Semantik bereit, die sich von der überschreibenden Semantik unterscheiden, die von den Iteratoren der C++-Sequenz und assoziativen Containern bereitgestellt wird. Die insert_iterator-Klasse ist für den Typ des Containers, der angepasst wird, vorlagenbasiert.

Syntax

template <class Container>
class insert_iterator;

Parameter

Container
Der Typ des Containers, in den Elementen von einem insert_iterator eingefügt werden sollen.

Hinweise

Der Container des Typs Container muss die Anforderungen für einen Container mit variabler Größe erfüllen und über eine Elementfunktion mit zwei Argumenten verfügen, wobei die Parameter vom Typ Container::iterator sind und Container::value_type die einen Typ Container::iteratorzurückgeben. Die C++-Standardbibliothekssequenz und sortierte assoziative Container erfüllen diese Anforderungen und können mit insert_iterator-Objekten angepasst werden. Für assoziative Container wird das Positionsargument als Hinweis behandelt, der die Leistung je nach Qualität potenziell verbessern oder verschlechtern kann. Ein insert_iterator muss immer mit seinem Container initialisiert werden.

Konstruktoren

TypeDefs

Operatoren

Anforderungen

Kopfzeile: <Iterator>

Namespace: std

insert_iterator::container_type

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

typedef Container container_type;

Hinweise

Der Typ ist synonym mit dem Vorlagenparameter Container.

Beispiel

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

int main( )
{
   using namespace std;

   list<int> L1;
   insert_iterator<list<int> >::container_type L2 = L1;
   inserter ( L2, L2.end ( ) ) = 20;
   inserter ( L2, L2.end ( ) ) = 10;
   inserter ( L2, L2.begin ( ) ) = 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 20 10 ).
*/

insert_iterator::insert_iterator

Erstellt einen insert_iterator, der ein Element an einer bestimmten Position in einen Container einfügt.

insert_iterator(Container& _Cont, typename Container::iterator _It);

Parameter

_Cont
Der Container, in den insert_iterator Elemente einfügen soll.

_Es
Die Position, an der eingefügt werden soll.

Hinweise

Für alle Container wird die Memberfunktion zum Einfügen von insert_iterator aufgerufen. Für zugehörige Container ist der Positionsparameter nur ein Vorschlag. Mit der Funktion zum Einfügen können Sie bequem Werte einfügen.

Beispiel

// insert_iterator_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 < 4 ; ++i )
   {
      L.push_back ( 10 * 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
   inserter ( L, L.begin ( ) ) = 2;

   // Alternatively, you may use the template version
   insert_iterator< list < int> > Iter(L, L.end ( ) );
*Iter = 300;

   cout << "After the 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:
( 10 20 30 ).
After the insertions, the list L is:
( 2 10 20 30 300 ).
*/

insert_iterator::operator*

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

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

// insert_iterator_op_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 = 0 ; i < 4 ; ++i )
   {
      L.push_back ( 2 * i );
   }

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

   insert_iterator< list < int> > Iter(L, L.begin ( ) );
*Iter = 10;
*Iter = 20;
*Iter = 30;

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

insert_iterator::operator++

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

insert_iterator<Container>& operator++();

insert_iterator<Container> operator++(int);

Parameter

Ein 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

// insert_iterator_op_incr.cpp
// compile with: /EHsc
#include <iterator>
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   vector<int> vec;
   for (i = 1 ; i < 5 ; ++i )
   {
      vec.push_back (  i );
   }

   vector <int>::iterator vIter;
   cout << "The vector vec is:\n ( ";
   for ( vIter = vec.begin ( ) ; vIter != vec.end ( ); vIter++ )
      cout << *vIter << " ";
   cout << ")." << endl;

   insert_iterator<vector<int> > ii ( vec, vec.begin ( ) );
*ii = 30;
   ii++;
*ii = 40;
   ii++;
*ii = 50;

   cout << "After the insertions, the vector vec becomes:\n ( ";
   for ( vIter = vec.begin ( ) ; vIter != vec.end ( ); vIter++ )
      cout << *vIter << " ";
   cout << ")." << endl;
}
/* Output:
The vector vec is:
( 1 2 3 4 ).
After the insertions, the vector vec becomes:
( 30 40 50 1 2 3 4 ).
*/

insert_iterator::operator=

Fügt einen Wert in einen Container ein, und gibt den Iterator, der aktualisiert wurde, um auf das neue Element zu verweisen.

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

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 in den Container eingefügte Element.

Hinweise

Der erster Memberoperator wertet Folgendes aus:

Iter = container->insert(Iter, val);

++Iter;

danach gibt er *this zurück.

Der zweite Memberoperator wertet Folgendes aus:

Iter = container->insert(Iter, std::move(val));

++Iter;

danach gibt er *this zurück.

Beispiel

// insert_iterator_op_assign.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 = 0 ; i < 4 ; ++i )
   {
      L.push_back ( 2 * i );
   }

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

   insert_iterator< list < int> > Iter(L, L.begin ( ) );
*Iter = 10;
*Iter = 20;
*Iter = 30;

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

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;

Hinweise

Ein Typ beschreibt den Verweis auf ein Element in der Sequenz, die durch den zugehörigen Container gesteuert wird.

Beispiel

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

int main( )
{
   using namespace std;

   list<int> L;
   insert_iterator<list<int> > iivIter( L , L.begin ( ) );
*iivIter = 10;
*iivIter = 20;
*iivIter = 30;

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

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

Siehe auch

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