Para ver el artículo en inglés, active la casilla Inglés. También puede ver el texto en inglés en una ventana emergente si pasa el puntero del mouse por el texto.
Traducción
Inglés
Se recomienda usar Visual Studio 2017

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
   );

_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 las la posición una más allá del último elemento en el primer intervalo de origen funcionó 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 origen o de la función de A (UD) utilizado en la segunda versión de algoritmo que se aplica en pares, en un orden frontal, los dos intervalos de origen.

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.

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;
}
          Vector original v1 = (-4 -3 -2 -1 0 1 2).
Los elementos vectoriales v1 multiplicado por 2 en el lugar proporcionan:
 v1mod = (-8 -6 -4 -2 0 2 4).
Multiplicar elementos de vector v1mod
 según el factor 5 & que copia en v2 proporciona:
 v2 = (-40 -30 -20 -10 0 10 20).
Multiplicando los elementos de los vectores v1mod y v2 en pares proporciona:
 v3 = (320 180 80 20 0 20 80).

Requisitos

Encabezado: <algorithm>

Espacio de nombres: std

Mostrar: