Classe raw_storage_iterator

Classe dell'adattatore fornita per consentire agli algoritmi di archiviare i rispettivi risultati nella memoria non inizializzata.

Sintassi

template <class OutputIterator, class Type>
    class raw_storage_iterator

Parametri

OutputIterator
Specifica l'iteratore di output per l'oggetto archiviato.

Type
Tipo di oggetto per cui viene allocata archiviazione.

Osservazioni:

La classe descrive un iteratore di output che costruisce oggetti di tipo Type nella sequenza generata. Oggetto della classe raw_storage_iterator<ForwardIterator, Type> accede all'archiviazione tramite un oggetto iteratore in avanti, della classe ForwardIterator, specificato quando si costruisce l'oggetto . Per un oggetto prima di classe ForwardIterator, l'espressione &*deve innanzitutto designare l'archiviazione non construita per l'oggetto successivo (di tipo Type) nella sequenza generata.

Questa classe adattatore viene usata quando è necessario separare l'allocazione della memoria e la costruzione di oggetti. L'oggetto raw_storage_iterator può essere usato per copiare oggetti nell'archiviazione non inizializzata, ad esempio la memoria allocata usando la funzione malloc.

Membri

Costruttori

Nome	Descrizione
raw_storage_iterator	Costruisce un iteratore di archiviazione non elaborato con un iteratore di output sottostante specificato.

Typedef

Nome	Descrizione
element_type	Fornisce un tipo che descrive un elemento da archiviare in un iteratore di archiviazione non elaborato.
iter_type	Fornisce un tipo che descrive un iteratore sottostante a un iteratore di archiviazione non elaborato.

Operatori

Nome	Descrizione
operator*	Operatore di dereferenziazione usato per implementare l'espressione dell'iteratore di output * ii = x.
operator=	Operatore di assegnazione usato per implementare l'espressione dell'iteratore di archiviazione non elaborato * i = x per l'archiviazione in memoria.
operator++	Operatori di incremento prefisso e incremento suffisso per iteratori di archiviazione non elaborati.

element_type

Fornisce un tipo che descrive un elemento da archiviare in un iteratore di archiviazione non elaborato.

typedef Type element_type;

Osservazioni:

Il tipo è un sinonimo del parametro Typedel modello di classe raw_storage_iterator .

iter_type

Fornisce un tipo che descrive un iteratore sottostante a un iteratore di archiviazione non elaborato.

typedef ForwardIterator iter_type;

Osservazioni:

Il tipo è un sinonimo del parametro di modello ForwardIterator.

operator*

Operatore di dereferenziazione usato per implementare l'espressione iteratore di archiviazione non elaborata * ii = x.

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

Valore restituito

Riferimento all'iteratore di archiviazione non elaborato

Osservazioni:

I requisiti per un ForwardIterator sono che l'iteratore di archiviazione non elaborato deve soddisfare, richiedere solo l'espressione * ii = t essere valida e che non dice nulla su operator o su operator= di essi. Gli operatori membro in questa implementazione, restituisce *this, in modo che operator=(constType&) possa eseguire l'archivio effettivo in un'espressione, ad esempio * ptr = val.

Esempio

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

operator=

Operatore di assegnazione usato per implementare l'espressione iteratore di archiviazione non elaborata * i = x per l'archiviazione in memoria.

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

Parametri

val
Valore dell'oggetto di tipo Type da inserire in memoria.

Valore restituito

L'operatore inserisce val in memoria, quindi restituisce un riferimento all'iteratore di archiviazione non elaborato.

Osservazioni:

I requisiti per uno ForwardIterator stato che l'iteratore di archiviazione non elaborato deve soddisfare, richiedono solo l'espressione * ii = t essere valida e che non dice nulla su operator o su operator= di essi. Questi operatori membro restituiscono *this.

L'operatore di assegnazione costruisce l'oggetto successivo nella sequenza di output usando il valore firstdell'iteratore archiviato , valutando la nuova espressione new ( (void*) & *first ) Type( val )di posizionamento .

Esempio

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

Operatori di incremento prefisso e incremento suffisso per iteratori di archiviazione non elaborati.

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

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

Valore restituito

Iteratore di archiviazione non elaborato o riferimento a un iteratore di archiviazione non elaborato.

Osservazioni:

Il primo operatore tenta infine di estrarre e archiviare un oggetto di tipo CharType dal flusso di input associato. Il secondo operatore esegue una copia dell'oggetto, incrementa l'oggetto, quindi restituisce la copia.

Il primo operatore di preincrement incrementa l'oggetto iteratore di output archiviato e quindi restituisce *this.

Il secondo operatore di postincrement crea una copia di *this, incrementa l'oggetto iteratore di output archiviato e quindi restituisce la copia.

Il costruttore archivia first come oggetto iteratore di output.

Esempio

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

Costruisce un iteratore di archiviazione non elaborato con un iteratore di output sottostante specificato.

explicit raw_storage_iterator(ForwardIterator first);

Parametri

first
L'iteratore in avanti sottostante all'oggetto raw_storage_iterator costruito.

Esempio

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