raw_storage_iterator (Clase)

Una clase de adaptador que se proporciona para permitir que los algoritmos almacenen sus resultados en memoria sin inicializar.

Sintaxis

template <class OutputIterator, class Type>
    class raw_storage_iterator

Parámetros

OutputIterator
Especifica el iterador de salida para el objeto que se almacena.

Tipo
Tipo de objeto al que se va a asignar almacenamiento.

Comentarios

La clase describe un iterador de salida que construye objetos de tipo Type en la secuencia que genera. Un objeto de clase raw_storage_iterator<ForwardIterator, Type> accede al almacenamiento mediante un objeto de iterador hacia delante de clase ForwardIterator que se especifica al construir el objeto. Para un objeto primero de la clase ForwardIterator, la expresión &*first debe designar almacenamiento no construido para el siguiente objeto (de tipo Type) en la secuencia generada.

Esta clase de adaptador se usa cuando es necesario separar la asignación de memoria y la construcción de objetos. raw_storage_iterator puede usarse para copiar objetos en el almacenamiento no inicializado, como la memoria asignada mediante la función malloc.

Miembros

Constructores

Nombre	Descripción
raw_storage_iterator	Crea un iterador de almacenamiento sin formato con un iterador de salida subyacente especificado.

Typedefs

Nombre	Descripción
element_type	Proporciona un tipo que describe un elemento para almacenar un iterador de almacenamiento sin formato.
iter_type	Proporciona un tipo que describe un iterador que subyace a un iterador de almacenamiento sin formato.

Operadores

Nombre	Descripción
operator*	Un operador de desreferencia usado para implementar la expresión del iterador de salida * ii = x.
operator=	Un operador de asignación usado para implementar la expresión del iterador de almacenamiento sin formato * i = x para almacenar en memoria.
operator++	Operadores de preincremento y prostincremento para los iteradores de almacenamiento sin formato.

element_type

Proporciona un tipo que describe un elemento para almacenar un iterador de almacenamiento sin formato.

typedef Type element_type;

Comentarios

El tipo es un sinónimo del parámetro de plantilla de clase raw_storage_iterator Type.

iter_type

Proporciona un tipo que describe un iterador que subyace a un iterador de almacenamiento sin formato.

typedef ForwardIterator iter_type;

Comentarios

El tipo es un sinónimo del parámetro de plantilla ForwardIterator.

operator*

Operador de desreferenciación usado para implementar la expresión de iterador de almacenamiento sin formato * ii = x.

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

Valor devuelto

Una referencia al iterador de almacenamiento sin formato

Comentarios

Los requisitos de ForwardIterator que el iterador de almacenamiento sin formato debe satisfacer solo requieren que la expresión * ii = t sea válida y que no indique nada sobre operator u operator= por su cuenta. Los operadores miembro de esta implementación devuelven *this, para que operator=(constType&) pueda realizar el almacén real en una expresión, como * ptr = val.

Ejemplo

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

Operador de asignación usado para implementar la expresión del iterador de almacenamiento sin formato * i = x para almacenar en memoria.

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

Parámetros

val
Valor del objeto de tipo Type que se va a insertar en la memoria.

Valor devuelto

El operador inserta val en la memoria y, después, devuelve una referencia al iterador de almacenamiento sin formato.

Comentarios

Los requisitos de un estado ForwardIterator que el iterador de almacenamiento sin formato debe satisfacer solo requieren que la expresión * ii = t sea válida y que no indique nada sobre operator u operator= por su cuenta. Estos operadores miembro devuelven *this.

El operador de asignación construye el siguiente objeto de la secuencia de salida con el valor del iterador almacenado first, mediante la evaluación de la expresión new de colocación new ( (void*) & *first ) Type( val ).

Ejemplo

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

Operadores de preincremento y prostincremento para los iteradores de almacenamiento sin formato.

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

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

Valor devuelto

Un iterador de almacenamiento sin formato o una referencia a uno.

Comentarios

El primer operador al final intenta extraer y almacenar un objeto de tipo CharType del flujo de entrada asociado. El segundo operador realiza una copia del objeto, lo incrementa y, después, devuelve la copia.

El primer operador preincremento incrementa el objeto de iterador de salida almacenado y luego devuelve *this.

El segundo operador postincremento realiza una copia de *this, incrementa el objeto de iterador de salida almacenado y luego devuelve la copia.

El constructor almacena first como objeto de iterador de salida.

Ejemplo

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

Crea un iterador de almacenamiento sin formato con un iterador de salida subyacente especificado.

explicit raw_storage_iterator(ForwardIterator first);

Parámetros

first
El iterador de reenvío que va a subyacer al objeto raw_storage_iterator que se está construyendo.

Ejemplo

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