transform

Applique un objet spécifié de fonction à chaque élément dans une plage source ou à une paire d'éléments des deux plages sources et copie les valeurs de retour de l'objet de fonction dans une plage de destination.

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

Paramètres

• _First1
  Un itérateur d'entrée adressant la position du premier élément de la première plage source à fonctionner sur.

• _Last1
  Un itérateur d'entrée adressant une position au delà de le dernier élément de la première plage source a opéré sur.

• _First2
  Un itérateur d'entrée adressant la position du premier élément de la deuxième plage source à fonctionner sur.

• _Result
  Un itérateur de sortie adressant la position du premier élément de la plage de destination.

• _Func
  Objet unaire défini par l'utilisateur de fonction utilisé dans la première version de l'algorithme appliqué à chaque élément du premier objet binaire défini par l'utilisateur de plage source ou de fonction d'Un (UD) utilisé dans la deuxième version de l'algorithme qui est appliqué par paires, dans un ordre en avant, des deux plages sources.

Valeur de retour

Un itérateur de sortie adressant une position au delà de le dernier élément dans la plage de destination qui accepte les éléments de sortie transformés par l'objet de fonction.

Notes

Les plages référencés doivent être valides ; tous les pointeurs doivent être deréférençables et dans chaque séquence la dernière position doit être accessible dès le début par l'augmentation.La plage de destination doit être assez étendu pour contenir la plage source transformée.

Si _Result est égal à _First1 défini dans la première version de l'algorithme*,* la source et les intervalles de destination seront identiques et la séquence sera modifiée en place.Mais _Result peut ne pas traiter une position dans la plage [_First1 +1, _Last1).

La complexité est linéaire avec au plus (_Last1 – _First1) des comparaisons.

Exemple

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

Configuration requise

en-tête : <algorithm>

l'espace de noms : DST

Voir aussi

Référence

Modèles Standard