transform

Applica un oggetto funzione specificata a ogni elemento in un intervallo di origine o a una coppia di elementi da due intervalli di origine e copia i valori restituiti dell'oggetto funzione in un intervallo di destinazione.

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

Parametri

• _First1
  Un iteratore di input destinato alla posizione del primo elemento del primo intervallo di origine da utilizzare.

• _Last1
  Un iteratore di input destinato alla posizione una dopo l'elemento finale del primo intervallo di origine eseguito su.

• _First2
  Un iteratore di input destinato alla posizione del primo elemento del secondo intervallo di origine da utilizzare.

• _Result
  Un iteratore di output destinato alla posizione del primo elemento nell'intervallo di destinazione.

• _Func
  Oggetto funzione unario definito dall'utente utilizzato nella prima versione dell'algoritmo applicato a ogni elemento del primo intervallo di origine o nell'oggetto funzione binario definito dall'utente A (UD) utilizzato nella seconda versione dell'algoritmo che si applica a coppie, in un ordine avanti, i due intervalli di origine.

Valore restituito

Un iteratore di output destinato alla posizione una dopo l'elemento finale nell'intervallo di destinazione che riceve gli elementi di output viene trasformato dall'oggetto funzione.

Note

Gli intervalli fatto riferimento siano validi, tutti i puntatori devono essere dereferenceable e all'interno di ogni sequenza dell'ultima posizione sia raggiungibile da prima dall'aumento.L'intervallo di destinazione deve essere sufficientemente ampio contenere l'intervallo di origine trasformato.

Se _Result viene impostato uguale a _First1 nella prima versione dell'algoritmo*,* il database di origine e gli intervalli di destinazione saranno lo stesso e la sequenza verrà modificata sul posto.Ma _Result non può utilizzare una posizione nell'intervallo [_First1 +1, _Last1).

Complessità è lineare con il massimo (_Last1 –) _First1confronti.

Esempio

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

Requisiti

intestazione: <algorithm>

Spazio dei nomi: deviazione standard

Vedere anche

Riferimenti

Libreria di modelli standard