raw_storage_iterator (Clase)

 

Para obtener la documentación más reciente de Visual Studio 2017 RC, consulte Documentación de Visual Studio 2017 RC.

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

template <class OutputIterator, class Type>  
class raw_storage_iterator

Parámetros

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

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

La clase describe un iterador de salida que construye objetos del tipo tipo en la secuencia que se genera. Un objeto de clase raw_storage_iterator < ForwardIterator, tipo> obtiene acceso al almacenamiento a través de un objeto de iterador hacia delante de la clase ForwardIterator, que especifica al construir el objeto. Para un objeto primero de la clase ForwardIterator, la expresión ** & *primer** debe designar el almacenamiento no construido para el siguiente objeto (de tipo tipo) 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.

Constructores

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

Definiciones de tipo

ELEMENT_TYPEProporciona un tipo que describe un elemento para almacenar un iterador de almacenamiento sin formato.
iter_typeProporciona un tipo que describe un iterador que subyace a un iterador de almacenamiento sin formato.

Operadores

operador *Un operador de desreferencia usado para implementar la expresión de iterador de salida * ii = x.
operador =Un operador de asignación que se utiliza 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.

Encabezado:<>>

Espacio de nombres: std

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 para el parámetro de plantilla de clase raw_storage_iterator tipo.

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.

Un operador de desreferencia usado para implementar la expresión de iterador de almacenamiento sin procesar * ii = x.

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

Valor devuelto

Una referencia al iterador de almacenamiento sin formato

Comentarios

Los requisitos para un ForwardIterator son que el iterador de almacenamiento debe satisfacer requieren únicamente la expresión * ii = t sea válido y que dice nada acerca de la operador o el operator= en sus propios. Los operadores de miembros en esta implementación devuelve ** *esto**, de modo que operador =( constTypeaspecto) puede 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;  
}  
\* Output:   
Not constructed.  
Copying 5  
Constructing 5  
*\  

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

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

Parámetros

val
El valor del objeto del tipo tipo va a insertar en la memoria.

Valor devuelto

Inserta el operador val en la memoria y, a continuación, devuelve una referencia al iterador almacenamiento sin procesar.

Comentarios

Los requisitos para un ForwardIterator estado que debe cumplir el iterador de almacenamiento sin procesar requiere sólo la expresión * ii = t sea válido y que dice nada acerca de la operador o operator= en sus propios. Estos operadores de miembro devuelven ** *esto**.

El operador de asignación construye el objeto siguiente en la secuencia de salida con el valor de iterador almacenado en primer lugar, al evaluar la expresión de selección de ubicación nueva nueva (( void *) aspecto* primer) tipo( 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;  
}  
\* Output:   
Not constructed.  
Copying 5  
Constructing 5  
*\  

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 un iterador de almacenamiento sin procesar.

Comentarios

El primer operador finalmente intenta extraer y almacenar un objeto de tipo CharType de flujo de entrada asociado. El segundo operador realiza una copia del objeto, incrementa el objeto y, a continuación, devuelve la copia.

El primer operador preincrement incrementa el objeto de iterador de salida almacenados y, a continuación, devuelve ** *esto**.

El segundo operador de incremento realiza una copia de ** *esto**, incrementa el objeto de iterador de salida almacenados y, a continuación, devuelve la copia.

Los almacenes de constructor primer como el 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;  
}  
\* Output:   
array 0 = 0  
array 1 = 2  
array 2 = 4  
array 3 = 6  
array 4 = 8  
*\  

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 hacia delante que subyacen a la raw_storage_iterator del objeto 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);  
}  
\* Output:   
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  
*\  

Seguridad para subprocesos en la biblioteca estándar de C++

Mostrar: