Partager via


transform

Applique un objet spécifié de la fonction à chaque élément dans une plage source ou une combinaison d'éléments de plusieurs plages sources et copie les valeurs de retour 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 adressage la position du premier élément de la première plage source à traiter sur.

  • _Last1
    Un itérateur d'entrée adressage la position une après l'élément final dans la première plage source est opéré sur.

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

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

  • _Func
    Objet unaire fonction définie par l'utilisateur utilisé pour la version initiale de l'algorithme appliqué à chaque élément dans le premier objet binaire défini par l'utilisateur de plage source ou de la fonction d'Un (UD) utilisé dans la deuxième version de l'algorithme appliqué par couple, dans un ordre par progression, les deux plages sources.

Valeur de retour

Un itérateur de sortie adressage la position une après l'élément final dans la plage de destination qui reçoit les éléments de sortie transformés l'objet de fonction.

Notes

Les plages référencées doivent être valides ; tous les pointeurs doivent être deréférençables et dans chaque séquence la dernière position doit être accessible la collection contenue par l'augmentation. La plage de destination doit être suffisamment grande pour contenir la plage source transformées.

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

La complexité un-à-un avec au plus_Last1 (–)_First1les 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 : <algorithme>

Espace de noms : std

Voir aussi

Référence

Bibliothèque STL (Standard Template Library)