transform

Se aplica un objeto especificado de la función a cada elemento de un intervalo de origen o un par de elementos de dos intervalos de origen y copia los valores devueltos del objeto function en un rango de destino.

template<class InputIterator, class OutputIterator, class UnaryFunction>
   OutputIterator transform(
      InputIterator _First1, 
      InputIterator _Last1, 
      OutputIterator _Result,
      UnaryFunction _Func
   );
template<class InputIterator1, class InputIterator2, class OutputIterator,
   class BinaryFunction>
   OutputIterator transform(
      InputIterator1 _First1, 
      InputIterator1 _Last1,
      InputIterator2 _First2, 
      OutputIterator _Result,
      BinaryFunction _Func
   );

Parámetros

• _First1
  Un iterador de entrada que dirige la posición del primer elemento en el primer intervalo de origen que se va a trabajar.

• _Last1
  Un iterador de entrada que dirige la posición una más allá del último elemento en el primer intervalo de origen operado en.

• _First2
  Un iterador de entrada que dirige la posición del primer elemento del intervalo de segundo origen que se va a trabajar.

• _Result
  Un iterador de salida que dirige la posición del primer elemento del intervalo de destino.

• _Func
  Objeto singular definida por el usuario de la función utilizado en la primera versión del algoritmo que se aplica a cada elemento del primer objeto binario definido por el usuario del intervalo de (UD) origen o de la función de A utilizado en la segunda versión de algoritmo que se aplica en pares, en un orden frontal, los dos intervalos de origen.

Valor devuelto

Un iterador de salida que las la posición una más allá del último elemento en el rango de destino que está recibiendo los elementos de salida transformó por el objeto function.

Comentarios

Los intervalos especificados deben ser válidos; todos los punteros deben ser dereferenceable y dentro de cada secuencia la posición última debe ser accesible de primera por el aumento.El intervalo de destino debe ser lo bastante grande para contener el intervalo de origen transformado.

Si _Result es igual a _First1 en la primera versión de algoritmo*,* el origen y los rangos de destino se iguales y la secuencia modificará en contexto.Pero _Result no puede resolver una posición dentro del intervalo [_First1 +1, _Last1).

La complejidad es lineal con como máximo (_Last1 – _First1) comparaciones.

Ejemplo

// alg_transform.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional>
#include <iostream>

// The function object multiplies an element by a Factor
template <class Type>
class MultValue
{
   private:
      Type Factor;   // The value to multiply by
   public:
      // Constructor initializes the value to multiply by
      MultValue ( const Type& _Val ) : Factor ( _Val ) {
      }

      // The function call for the element to be multiplied
      Type operator ( ) ( Type& elem ) const 
      {
         return elem * Factor;
      }
};

int main( )
{
   using namespace std;
   vector <int> v1, v2 ( 7 ), v3 ( 7 );
   vector <int>::iterator Iter1, Iter2 , Iter3;

   // Constructing vector v1
   int i;
   for ( i = -4 ; i <= 2 ; i++ )
   {
      v1.push_back(  i );
   }

   cout << "Original vector  v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")." << endl;

   // Modifying the vector v1 in place
   transform (v1.begin ( ) , v1.end ( ) , v1.begin ( ) , MultValue<int> ( 2 ) );
   cout << "The elements of the vector v1 multiplied by 2 in place gives:"
        << "\n v1mod = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")." << endl;

   // Using transform to multiply each element by a factor of 5
   transform ( v1.begin ( ) , v1.end ( ) , v2.begin ( ) , MultValue<int> ( 5 ) );
   
   cout << "Multiplying the elements of the vector v1mod\n "
        <<  "by the factor 5 & copying to v2 gives:\n v2 = ( " ;
   for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
      cout << *Iter2 << " ";
   cout << ")." << endl;

   // The second version of transform used to multiply the 
   // elements of the vectors v1mod & v2 pairwise
   transform ( v1.begin ( ) , v1.end ( ) ,  v2.begin ( ) , v3.begin ( ) , 
      multiplies <int> ( ) );
   
   cout << "Multiplying elements of the vectors v1mod and v2 pairwise "
        <<  "gives:\n v3 = ( " ;
   for ( Iter3 = v3.begin( ) ; Iter3 != v3.end( ) ; Iter3++ )
      cout << *Iter3 << " ";
   cout << ")." << endl;
}

Requisitos

encabezado: <algoritmo>

espacio de nombres: std

Vea también

Referencia

Biblioteca de plantillas estándar