raw_storage_iterator, classe

Classe d'adaptateur fournie pour permettre aux algorithmes de stocker leurs résultats dans la mémoire non initialisée.

Syntaxe

template <class OutputIterator, class Type>
    class raw_storage_iterator

Paramètres

OutputIterator
Spécifie l'itérateur de sortie de l'objet stocké.

Type
Type d'objet pour lequel le stockage est alloué.

Notes

La classe décrit un itérateur de sortie qui construit des objets de type Type dans la séquence qu’elle génère. Objet de classe raw_storage_iterator<ForwardIterator, Type> accède au stockage via un objet itérateur de transfert, de classe ForwardIterator, que vous spécifiez lorsque vous construisez l’objet. Pour un objet premier de classe ForwardIterator, l’expression &*first doit désigner un stockage nonconstructé pour l’objet suivant (de type Type) dans la séquence générée.

Cette classe d’adaptateur est utilisée lorsqu’il est nécessaire de séparer l’allocation de mémoire et la construction d’objets. Le raw_storage_iterator peut être utilisé pour copier des objets dans le stockage non initialisé, comme la mémoire allouée à l'aide de la fonction malloc.

Membres

Constructeurs

Typedefs

Opérateurs

element_type

Fournit un type qui décrit un élément à stocker dans un itérateur de stockage brut.

typedef Type element_type;

Notes

Le type est un synonyme du paramètre Typede modèle de classe raw_storage_iterator.

iter_type

Fournit un type qui décrit un itérateur sous-jacent à un itérateur de stockage brut.

typedef ForwardIterator iter_type;

Notes

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

operator*

Opérateur de déreferencing utilisé pour implémenter l’expression itérateur de stockage brute * ii = x.

raw_storage_iterator<ForwardIterator, Type>& operator*();

Valeur de retour

Référence à l’itérateur de stockage brut

Notes

Les exigences d’un ForwardIterator sont que l’itérateur de stockage brut doit satisfaire, n’exige que l’expression * ii = ne soit pas valide et qu’elle ne dit rien sur le ou sur operator operator= leur propre. Les opérateurs membres de cette implémentation retournent *this, afin que operator=(constType&) puisse effectuer le magasin réel dans une expression, par exemple * ptr = val.

Exemple

// raw_storage_iterator_op_deref.cpp
// compile with: /EHsc
#include <iostream>
#include <iterator>
#include <memory>
#include <list>
using namespace std;

class Int
{
public:
   Int(int i)
   {
      cout << "Constructing " << i << endl;
      x = i;
      bIsConstructed = true;
   };

   Int &operator=(int i)
   {
      if (!bIsConstructed)
         cout << "Not constructed.\n";
      cout << "Copying " << i << endl;
      x = i;
      return *this;
   };

   int x;

private:
   bool bIsConstructed;
};

int main( void)
{
   Int *pInt = ( Int* ) malloc( sizeof( Int ) );
   memset( pInt, 0, sizeof( Int ) ); // Set bIsConstructed to false;
*pInt = 5;
   raw_storage_iterator< Int*, Int > it( pInt );
*it = 5;
}

Not constructed.
Copying 5
Constructing 5

opérateur =

Opérateur d’affectation utilisé pour implémenter l’expression d’itérateur de stockage brut * i = x pour le stockage en mémoire.

raw_storage_iterator<ForwardIterator, Type>& operator=(
    const Type& val);

Paramètres

val
Valeur de l’objet de type Type à insérer dans la mémoire.

Valeur de retour

L’opérateur stocke val dans la mémoire, puis retourne une référence à l’itérateur de stockage brut.

Notes

Les exigences d’un ForwardIterator état que l’itérateur de stockage brut doit satisfaire, ne nécessitent que l’expression * ii = n’est pas valide, et qu’elle ne dit rien sur le ou sur operator operator= leur propre. Ces opérateurs membres retournent *this.

L’opérateur d’affectation construit l’objet suivant dans la séquence de sortie à l’aide de la valeur firstd’itérateur stockée, en évaluant la nouvelle expression new ( (void*) & *first ) Type( val )de placement.

Exemple

// raw_storage_iterator_op_assign.cpp
// compile with: /EHsc
#include <iostream>
#include <iterator>
#include <memory>
#include <list>
using namespace std;

class Int
{
public:
   Int( int i )
   {
      cout << "Constructing " << i << endl;
      x = i;
      bIsConstructed = true;
   };
   Int &operator=( int i )
   {
      if ( !bIsConstructed )
         cout << "Not constructed.\n";
      cout << "Copying " << i << endl; x = i;
      return *this;
   };
   int x;
private:
   bool bIsConstructed;
};

int main( void )
{
   Int *pInt = ( Int* )malloc( sizeof( Int ) );
   memset( pInt, 0, sizeof( Int ) ); // Set bIsConstructed to false;

*pInt = 5;

   raw_storage_iterator<Int*, Int> it( pInt );
*it = 5;
}

Not constructed.
Copying 5
Constructing 5

operator++

Opérateurs de préincrémentation et de postincrémentation pour les itérateurs de stockage brut.

raw_storage_iterator<ForwardIterator, Type>& operator++();

raw_storage_iterator<ForwardIterator, Type> operator++(int);

Valeur de retour

Itérateur de stockage brut ou référence à un itérateur de stockage brut.

Notes

Le premier opérateur tente finalement d’extraire et de stocker un objet de type CharType à partir du flux d’entrée associé. Le deuxième opérateur effectue une copie de l’objet, incrémente l’objet, puis retourne la copie.

Le premier opérateur de préincrément incrémente l’objet itérateur de sortie stocké, puis retourne *this.

Le deuxième opérateur de postincrement effectue une copie de , incrémente l’objet itérateur de *thissortie stocké, puis retourne la copie.

Le constructeur stocke first comme objet itérateur de sortie.

Exemple

// raw_storage_iterator_op_incr.cpp
// compile with: /EHsc
#include <iostream>
#include <iterator>
#include <memory>
#include <list>
using namespace std;

int main( void )
{
   int *pInt = new int[5];
   std::raw_storage_iterator<int*,int> it( pInt );
   for ( int i = 0; i < 5; i++, it++ ) {
      *it = 2 * i;
   };

   for ( int i = 0; i < 5; i++ ) cout << "array " << i << " = " << pInt[i] << endl;;

   delete[] pInt;
}

array 0 = 0
array 1 = 2
array 2 = 4
array 3 = 6
array 4 = 8

raw_storage_iterator

Construit un itérateur de stockage brut avec un itérateur de sortie sous-jacent spécifié.

explicit raw_storage_iterator(ForwardIterator first);

Paramètres

first
Itérateur vers l’avant devant être sous-jacent à l’objet raw_storage_iterator construit.

Exemple

// raw_storage_iterator_ctor.cpp
// compile with: /EHsc /W3
#include <iostream>
#include <iterator>
#include <memory>
#include <list>
using namespace std;

class Int
{
public:
   Int(int i)
   {
      cout << "Constructing " << i << endl;
      x = i;
      bIsConstructed = true;
   };
   Int &operator=( int i )
   {
      if (!bIsConstructed)
         cout << "Error! I'm not constructed!\n";
      cout << "Copying " << i << endl;  x = i; return *this;
   };
   int x;
   bool bIsConstructed;
};

int main( void )
{
   std::list<int> l;
   l.push_back( 1 );
   l.push_back( 2 );
   l.push_back( 3 );
   l.push_back( 4 );

   Int *pInt = (Int*)malloc(sizeof(Int)*l.size( ));
   memset (pInt, 0, sizeof(Int)*l.size( ));
   // Hack: make sure bIsConstructed is false

   std::copy( l.begin( ), l.end( ), pInt );  // C4996
   for (unsigned int i = 0; i < l.size( ); i++)
      cout << "array " << i << " = " << pInt[i].x << endl;;

   memset (pInt, 0, sizeof(Int)*l.size( ));
   // hack: make sure bIsConstructed is false

   std::copy( l.begin( ), l.end( ),
      std::raw_storage_iterator<Int*,Int>(pInt));  // C4996
   for (unsigned int i = 0; i < l.size( ); i++ )
      cout << "array " << i << " = " << pInt[i].x << endl;

   free(pInt);
}

Error! I'm not constructed!
Copying 1
Error! I'm not constructed!
Copying 2
Error! I'm not constructed!
Copying 3
Error! I'm not constructed!
Copying 4
array 0 = 1
array 1 = 2
array 2 = 3
array 3 = 4
Constructing 1
Constructing 2
Constructing 3
Constructing 4
array 0 = 1
array 1 = 2
array 2 = 3
array 3 = 4