raw_storage_iterator-Klasse

Eine Adapterklasse, die bereitgestellt wird, um Algorithmen das Speichern ihrer Ergebnisse in nicht initialisiertem Speicher zu ermöglichen.

Syntax

template <class OutputIterator, class Type>
    class raw_storage_iterator

Parameter

OutputIterator
Gibt den Ausgabeiterator für das Objekt an, das gespeichert wird.

Typ
Der Typ des Objekts, dem Speicher zugeordnet wird.

Hinweise

Die Klasse beschreibt einen Ausgabe-Iterator, der Objekte vom Typ Type in der generierten Sequenz erstellt. Ein Objekt der Klasse raw_storage_iterator<ForwardIterator, Type> greift auf speicher über ein Forward Iterator-Objekt der Klasse ForwardIteratorzu, die Sie beim Erstellen des Objekts angeben. Für ein Objekt zuerst der Klasse ForwardIteratormuss der Ausdruck &*zuerst unstrukturierten Speicher für das nächste Objekt (vom Typ Type) in der generierten Sequenz festlegen.

Diese Adapterklasse wird verwendet, wenn es erforderlich ist, die Speicherzuweisung und die Objektkonstruktion zu trennen. raw_storage_iterator kann verwendet werden, um Objekte in nicht initialisierten Speicher zu kopieren, beispielsweise Arbeitsspeicher, der über die malloc-Funktion zugeordnet wurde.

Member

Konstruktoren

Name	Beschreibung
raw_storage_iterator	Erstellt einen unformatierten Speicheriterator mit einem angegebenen zugrunde liegenden Ausgabeiterator.

TypeDefs

Name	Beschreibung
element_type	Stellt einen Typ bereit, der ein Element beschreibt, das in einem unformatierten Speicheriterator gespeichert werden soll.
iter_type	Stellt einen Typ bereit, der einen Iterator beschreibt, der einem unformatierten Speicheriterator zugrunde liegt.

Operatoren

Name	Beschreibung
operator*	Ein Dereferenzierungsoperator, der zum Implementieren des Ausgabeiteratorausdrucks *ii = x verwendet wird.
operator=	Ein Zuweisungsoperator, der dazu verwendet wird, den für einen unformatierten Speicheriterator verwendeten Ausdruck *i = x zu implementieren, damit er im Arbeitsspeicher gespeichert werden kann.
operator++	Inkrementoperatoren in Präfix- und Postfix-Notation für unformatierte Speicheriteratoren.

element_type

Stellt einen Typ bereit, der ein Element beschreibt, das in einem unformatierten Speicheriterator gespeichert werden soll.

typedef Type element_type;

Hinweise

Der Typ ist ein Synonym für den raw_storage_iterator Klassenvorlagenparameter Type.

iter_type

Stellt einen Typ bereit, der einen Iterator beschreibt, der einem unformatierten Speicheriterator zugrunde liegt.

typedef ForwardIterator iter_type;

Hinweise

Der Type stellt ein Synonym für den Vorlagenparameter ForwardIteratordar.

operator*

Ein Dereferencing-Operator, der zum Implementieren des rohen Speicher iteratorausdrucks * ii = x verwendet wird.

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

Rückgabewert

Ein Verweis auf den unformatierten Speicheriterator.

Hinweise

Die Anforderungen für eine ForwardIterator sind, dass der Rohspeicher iterator erfüllen muss, nur den Ausdruck * ii = nicht gültig sein und dass es nichts über das operator oder das operator= allein sagt. Die Memberoperatoren in dieser Implementierung werden zurückgegeben *this, damit operator=(constType&) den tatsächlichen Speicher in einem Ausdruck ausführen kann, z. B. * ptr = val.

Beispiel

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

Zuordnungsoperator zum Implementieren des Rohspeicher iteratorausdrucks * i = x zum Speichern im Speicher.

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

Parameter

val
Der Wert des Typobjekts Type , das in den Arbeitsspeicher eingefügt werden soll.

Rückgabewert

Der Operator fügt val in den Speicher ein, und gibt dann einen Verweis auf den unformatierten Speicheriterator zurück.

Hinweise

Die Anforderungen für einen ForwardIterator Zustand, den der Rohspeicher-Iterator erfüllen muss, erfordert nur den Ausdruck * ii = nicht gültig, und dass es nichts über das operator oder das operator= allein sagt. Diese Memberoperatoren geben zurück *this.

Der Zuordnungsoperator erstellt das nächste Objekt in der Ausgabesequenz mithilfe des gespeicherten Iteratorwerts first, indem der platzierungsneue Ausdruck new ( (void*) & *first ) Type( val )ausgewertet wird.

Beispiel

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

Inkrementoperatoren in Präfix- und Postfix-Notation für unformatierte Speicheriteratoren.

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

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

Rückgabewert

Ein Unformatierter Speicher-Iterator oder ein Verweis auf einen Unformatierten Speicher-Iterator.

Hinweise

Der erste Operator versucht schließlich, ein Objekt vom Typ CharType aus dem zugeordneten Eingabedatenstrom zu extrahieren und zu speichern. Der zweite Operator erstellt eine Kopie des Objekts, inkrementiert das Objekt und gibt dann die Kopie zurück.

Der erste Vorschrittoperator erhöht das gespeicherte Ausgabe iterator-Objekt und gibt dann zurück *this.

Der zweite Postincrement-Operator erstellt eine Kopie von *this, erhöht das gespeicherte Ausgabe iterator -Objekt und gibt dann die Kopie zurück.

Der Konstruktor wird als Ausgabe iteratorobjekt gespeichert first .

Beispiel

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

Erstellt einen unformatierten Speicheriterator mit einem angegebenen zugrunde liegenden Ausgabeiterator.

explicit raw_storage_iterator(ForwardIterator first);

Parameter

first
Der Forward-Iterator, mit dem das raw_storage_iterator-Objekt erstellt wird.

Beispiel

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