front_insert_iterator, classe

Décrit un adaptateur d’itérateur qui répond aux exigences d’un itérateur de sortie. Il insère, au lieu de remplacer, les éléments dans le devant d’une séquence. Il fournit ainsi une sémantique différente de la sémantique de remplacement fournie par les itérateurs des conteneurs de séquence C++. La classe front_insert_iterator est mise en modèle d'après le type de conteneur.

Syntaxe

template <class Container>
class front_insert_iterator;

Paramètres

Conteneur
Type de conteneur au début duquel des éléments doivent être insérés par un front_insert_iterator.

Notes

Le conteneur doit répondre aux exigences d’une insertion de début de séquence où il est possible d’insérer des éléments au début de la séquence dans le temps fixe amorti. Les conteneurs de séquence de bibliothèque C++ Standard définis par la classe deque et la classe list fournissent la fonction membre push_front nécessaire et répondent à ces exigences. En revanche, les conteneurs de séquences définis par la classe vectorielle ne répondent pas à ces exigences et ne peuvent pas être adaptés à l’utilisation avec front_insert_iterators. Un front_insert_iterator doit toujours être initialisé avec son conteneur.

Constructeurs

Typedefs

Opérateurs

Spécifications

En-tête : <itérateur>

Espace de noms : std

front_insert_iterator ::container_type

Type qui représente le conteneur dans lequel une insertion de début doit être effectuée.

typedef Container container_type;

Notes

Le type est un synonyme du paramètre de modèle Container.

Exemple

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

Crée un itérateur qui peut insérer des éléments au début d'un objet conteneur spécifié.

explicit front_insert_iterator(Container& _Cont);

Paramètres

_Suite
Objet de conteneur dans lequel front_insert_iterator doit insérer des éléments.

Valeur de retour

front_insert_iterator pour l’objet conteneur du paramètre.

Exemple

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

Supprime la référence à l’itérateur d’insertion retournant l’élément ciblé.

front_insert_iterator<Container>& operator*();

Valeur de retour

La fonction membre retourne la valeur de l’élément ciblé.

Notes

Utilisé pour implémenter l’expression d’itérateur de sortie *Valeur Iter = . S’il Iter s’agit d’un itérateur qui traite un élément d’une séquence, la valeur *Iter = remplace cet élément par valeur et ne modifie pas le nombre total d’éléments dans la séquence.

Exemple

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

Incrémente le back_insert_iterator à l'emplacement suivant où une valeur peut être stockée.

front_insert_iterator<Container>& operator++();

front_insert_iterator<Container> operator++(int);

Valeur de retour

front_insert_iterator qui cible l’emplacement suivant où une valeur peut être stockée.

Notes

Les opérateurs de préincrémentation et de postincrémentation retournent le même résultat.

Exemple

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

Ajoute (push) une valeur au début du conteneur.

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

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

Paramètres

val
Valeur à assigner au conteneur.

Valeur de retour

Référence au dernier élément inséré au début du conteneur.

Notes

Le premier opérateur membre évalue container.push_front( val), puis retourne *this.

Le deuxième opérateur membre évalue

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

puis retourne *this.

Exemple

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

Type qui fournit une référence à un élément dans une séquence contrôlée par le conteneur associé.

typedef typename Container::reference reference;

Exemple

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

Voir aussi

<iterator>
Sécurité des threads dans la bibliothèque C++ Standard
Informations de référence sur la bibliothèque standard C++