uninitialized_copy

Copia los objetos de un intervalo de origen especificado en un rango de destino sin inicializar.

template<class InputIterator, class ForwardIterator>
   ForwardIterator uninitialized_copy(
      InputIterator _First, 
      InputIterator _Last,
      ForwardIterator _Dest
   );

Parámetros

_First
Un iterador de entrada que dirige el primer elemento del intervalo de origen.
_Last
Un iterador de entrada que dirige el último elemento del intervalo de origen.
_Dest
Un iterador hacia delante que dirige el primer elemento del intervalo de destino.

Valor devuelto

Un iterador hacia delante que dirige la primera posición más allá del rango de destino, a menos que el intervalo de origen fuera _Firstvacío y de iterador de direcciones .

Comentarios

Este algoritmo permite se desacoplan de asignación de memoria de la construcción de objetos.

La función de la plantilla se ejecuta eficazmente:

while ( _First!= _Last )
   new ( ( void * )&*_Dest ++)
      iterator_traits<InputIterator>::value_type ( *_First ++ );
return _First;

a menos que el código produce una excepción.En ese caso, se destruyen todos los objetos construidos y la excepción se reinician.

uninitialized_copy tiene dos formularios relacionados:

checked_uninitialized_copy

unchecked_uninitialized_copy

Para obtener más información sobre cómo estas funciones se comportan, vea Iteradores comprobados.

Ejemplo

// memory_uninit_copy.cpp
// compile with: /EHsc /W3
#include <memory>
#include <iostream>

using namespace std;

   class Integer 
   {
   public:
      Integer( int x ) : val( x ) {}
      int get( ) { return val; }
   private:
      int val;
   };

int main( )
{
   int Array[] = { 10, 20, 30, 40 };
   const int N = sizeof( Array ) / sizeof( int );

   int i;
   cout << "The initialized Array contains " << N << " elements: ";
      for (i = 0 ; i < N; i++ )
      {
         cout << " " << Array [ i ];
      }
   cout << endl;

   Integer* ArrayPtr = ( Integer* ) malloc( N * sizeof( int ) );
   Integer* LArrayPtr = uninitialized_copy(
      Array, Array + N, ArrayPtr);  // C4996

   cout << "Address of position after the last element in the array is: " 
        << &Array[0] + N << endl;
   cout << "The iterator returned by uninitialized_copy addresses: " 
        << ( void* )LArrayPtr << endl;
   cout << "The address just beyond the last copied element is: " 
        << ( void* )( ArrayPtr + N ) << endl;

   if ( ( &Array[0] + N ) == ( void* )LArrayPtr )
      cout << "The return value is an iterator "
           << "pointing just beyond the original array." << endl;
   else
      cout << "The return value is an iterator "
           << "not pointing just beyond the original array." << endl;

   if ( ( void* )LArrayPtr == ( void* )( ArrayPtr + N ) )
      cout << "The return value is an iterator "
           << "pointing just beyond the copied array." << endl;
   else
      cout << "The return value is an iterator "
           << "not pointing just beyond the copied array." << endl;

   free ( ArrayPtr );

   cout << "Note that the exact addresses returned will vary\n"
        << "with the memory allocation in individual computers."
        << endl;
}

Resultado del ejemplo

The initialized Array contains 4 elements: 10 20 30 40
Address of position after the last element in the array is: 0012FED8
The iterator returned by uninitialized_copy addresses: 00311B88
The address just beyond the last copied element is: 00311B88
The return value is an iterator not pointing just beyond the original array.
The return value is an iterator pointing just beyond the copied array.
Note that the exact addresses returned will vary
with  the memory allocation in individual computers.

Requisitos

encabezado: <memoria>

espacio de nombres: std

Last updated on 2013-03-15