Classe raw_storage_iterator

Uma classe de adaptador que é fornecida para permitir que algoritmos armazenem seus resultados na memória não inicializada.

Sintaxe

template <class OutputIterator, class Type>
    class raw_storage_iterator

Parâmetros

OutputIterator
Especifica o iterador de saída para o objeto que está sendo armazenado.

Tipo
O tipo de objeto para o qual o armazenamento está sendo alocado.

Comentários

A classe descreve um iterador de saída que constrói objetos do tipo Type na sequência gerada. Um objeto da classe raw_storage_iterator<ForwardIterator, Type> acessa o armazenamento por meio de um objeto de iterador de avanço, da classe ForwardIterator, especificada ao construir o objeto. Para um objeto first of class ForwardIterator, a expressão &*first deve designar armazenamento não construído para o próximo objeto (do tipo Type) na sequência gerada.

Essa classe de adaptador é usada quando é necessário separar a alocação de memória e a construção de objetos. O raw_storage_iterator pode ser usado para copiar objetos no armazenamento não inicializado, tal como memória alocada usando a função malloc.

Membros

Construtores

Typedefs

Operadores

element_type

Fornece um tipo que descreve um elemento a ser armazenado em um iterador de armazenamento bruto.

typedef Type element_type;

Comentários

O tipo é um sinônimo do parâmetro de modelo de classe raw_storage_iterator Type.

iter_type

Fornece um tipo que descreve um iterador que dá suporte a um iterador de armazenamento bruto.

typedef ForwardIterator iter_type;

Comentários

O tipo é um sinônimo do parâmetro de modeloForwardIterator.

operator*

Um operador de desreferenciamento usado para implementar a expressão do iterador de armazenamento bruto * ii = x.

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

Valor de retorno

Uma referência ao iterador de armazenamento bruto

Comentários

Os requisitos para um ForwardIterator que o iterador de armazenamento bruto precisa satisfazer exigem somente que a expressão * ii = t seja válida e que ela não diga nada sobre o operator ou o operator= por conta própria. Os operadores de membro nesta implementação retornam *this, para que operator=(constType&) possa executar o armazenamento real em uma expressão, como * ptr = val.

Exemplo

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

Um operador de atribuição usado para implementar a expressão do iterador de armazenamento bruto * i = x para armazenamento na memória.

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

Parâmetros

val
O valor do objeto do tipo Type a ser inserido na memória.

Valor de retorno

O operador insere val na memória e, em seguida, retorna uma referência ao iterador de armazenamento bruto.

Comentários

Os requisitos para um estado ForwardIterator que o iterador de armazenamento bruto precisa satisfazer exigem somente que a expressão * ii = t seja válida e que ela não diga nada sobre o operator ou o operator= por conta própria. Esses operadores membros retornam *this.

O operador de atribuição constrói o próximo objeto na sequência da saída usando o valor de iterador armazenado first, avaliando a expressão de novo posicionamento new ( (void*) & *first ) Type( val ).

Exemplo

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

operador++

Operadores pré e pós-incremento para iteradores de armazenamento brutos.

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

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

Valor de retorno

Um iterador de armazenamento bruto ou uma referência a um iterador de armazenamento bruto.

Comentários

O primeiro operador eventualmente tenta extrair e armazenar um objeto do tipo CharType do fluxo de entrada associado. O segundo operador faz uma cópia do objeto, incrementa o objeto e, em seguida, retorna a cópia.

O primeiro operador pré-incremento incrementa o objeto de iterador de saída armazenado e retorna *this.

O segundo operador pós-incremento faz uma cópia de *this, incrementa o objeto de iterador de saída e retorna a cópia.

O construtor armazena first como o objeto de iterador de saída.

Exemplo

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

Constrói um iterador de armazenamento bruto com um iterador de saída subjacente especificado.

explicit raw_storage_iterator(ForwardIterator first);

Parâmetros

first
O iterador de avanço que dá suporte ao objeto raw_storage_iterator que está sendo construído.

Exemplo

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