Namespaces
Variants

std::experimental::ranges:: equal_to

From cppreference.net
C++
Experimental
Ranges
General utilities library
Défini dans l'en-tête <experimental/ranges/functional>
template < class T = void >

requires EqualityComparable < T > ||
Same < T, void > ||
/* == on two const T lvalues invokes a built-in operator comparing pointers */

struct equal_to ;
(ranges TS)
template <>
struct equal_to < void > ;
(ranges TS)

Fonction objet pour effectuer des comparaisons. Le modèle primaire invoque operator == sur les lvalues constantes de type T . La spécialisation equal_to<void> déduit les types de paramètres de l'opérateur d'appel de fonction à partir des arguments (mais pas le type de retour).

Toutes les spécialisations de equal_to sont Semiregular .

Table des matières

Types membres

Type de membre Définition
is_transparent (membre uniquement de equal_to<void> spécialisation) /* non spécifié */

Fonctions membres

operator()
vérifie si les arguments sont égaux
(fonction membre publique)

std::experimental::ranges::equal_to:: operator()

constexpr bool operator ( ) ( const T & x, const T & y ) const ;
(1) (membre uniquement du template principal equal_to<T> )
template < class T, class U >

requires EqualityComparableWith < T, U > ||
/* std::declval<T>() == std::declval<U>() se résout en
un opérateur intégré comparant des pointeurs */

constexpr bool operator ( ) ( T && t, U && u ) const ;
(2) (membre uniquement de la spécialisation equal_to<void> )
1) Compare x et y . Équivalent à return ranges:: equal_to <> { } ( x, y ) ; .
2) Compare t et u . Équivalent à return std:: forward < T > ( t ) == std:: forward < U > ( u ) ; , sauf lorsque cette expression se résout en un appel à un operator == intégré comparant des pointeurs.

Lorsqu'un appel à (1) ou (2) invoquerait un opérateur intégré comparant des pointeurs de type P , le résultat est déterminé comme suit :

  • Retourne false si l'une des valeurs (éventuellement converties) du premier argument et la valeur (éventuellement convertie) du second argument précède l'autre dans l'ordre total strict défini par l'implémentation sur toutes les valeurs de pointeurs de type P . Cet ordre total strict est cohérent avec l'ordre partiel imposé par les opérateurs intégrés < , > , <= , et >= .
  • Sinon (aucun ne précède l'autre), retourne true .

Le comportement est indéfini sauf si les séquences de conversion de T et U vers P préservent l'égalité (voir ci-dessous).

Préservation de l'égalité

Une expression préserve l'égalité si elle produit des sorties égales pour des entrées égales.

  • Les entrées d'une expression consistent en ses opérandes.
  • Les sorties d'une expression consistent en son résultat et tous les opérandes modifiés par l'expression (le cas échéant).

Toute expression requise pour préserver l'égalité doit en outre être stable : deux évaluations d'une telle expression avec les mêmes objets d'entrée doivent avoir des sorties égales en l'absence de toute modification explicite intervenant entre ces objets d'entrée.

Notes

Contrairement à std::equal_to , ranges::equal_to exige que les deux opérateurs == et != soient valides (via les contraintes EqualityComparable et EqualityComparableWith ).

Exemple

Cette section est incomplète
Raison : aucun exemple

Voir aussi

objet fonction implémentant x == y
(modèle de classe)