equal_to, struct

Un prédicat binaire qui exécute l'opération d'égalité (operator==) à ses arguments.

template<class Type = void>
   struct equal_to : public binary_function<Type, Type, bool> 
   {
      bool operator()(
         const Type& Left, 
         const Type& Right
      ) const;
   };

// specialized transparent functor for operator==
template<>
   struct equal_to<void>
   {
      template<class Type1, class Type2>
      auto operator()(Type1&& Left, Type2&& Right) const
         -> decltype(std::forward<Type1>(Left)
            == std::forward<Type2>(Right));
   };

Paramètres

• Type, Type1, Type2
  Tout type qui prend en charge operator== qui prend des opérandes des types spécifiés ou déduits.

• Left
  L'opérande de gauche de l'opération d'égalité. Le modèle non spécialisé prend un argument de référence lvalue de type Type. Le modèle spécialisé perfectionne le transfert des arguments de référence lvalue et rvalue de type déduit Type1.

• Right
  L'opérande de droite de l'opération d'égalité. Le modèle non spécialisé prend un argument de référence lvalue de type Type. Le modèle spécialisé perfectionne le transfert des arguments de référence lvalue et rvalue de type déduit Type2.

Valeur de retour

Le résultat de Left * == + Right. Le modèle spécialisé effectue de façon parfaite le transfert du résultat, qui a le type retourné par operator==.

Notes

Les objets de type Type doivent être comparable au sens de l'égalité. Cela nécessite que operator== défini sur l'ensemble d'objets réponde aux propriétés mathématiques d'une relation d'équivalence. Tous les types numériques et pointeurs intégrés satisfont cette spécification.

Exemple

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

using namespace std;

int main( )
{
   vector <double> v1, v2, v3 ( 6 );
   vector <double>::iterator Iter1, Iter2, Iter3;
   
   int i;
   for ( i = 0 ; i <= 5 ; i+=2 )
   {
      v1.push_back( 2.0 *i );
      v1.push_back( 2.0 * i + 1.0 );
   }

   int j;
   for ( j = 0 ; j <= 5 ; j+=2 )
   {
      v2.push_back( - 2.0 * j );
      v2.push_back( 2.0 * j + 1.0 );
   }

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

   cout << "The vector v2 = ( " ;
   for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
      cout << *Iter2 << " ";
   cout << ")" << endl;

   // Testing for the element-wise equality between v1 & v2
   transform ( v1.begin( ),  v1.end( ), v2.begin( ), v3.begin ( ), 
      equal_to<double>( ) );

   cout << "The result of the element-wise equal_to comparison\n"
      << "between v1 & v2 is: ( " ;
   for ( Iter3 = v3.begin( ) ; Iter3 != v3.end( ) ; Iter3++ )
      cout << *Iter3 << " ";
   cout << ")" << endl;
}