Namespaces
Variants

std::experimental::ranges:: not_equal_to

From cppreference.net
Défini dans l'en-tête <experimental/ranges/functional>
template < class T = void >

requires EqualityComparable < T > ||
Same < T, void > ||
/* == sur deux lvalues const T invoque un opérateur intégré comparant des pointeurs */

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

Fonction objet pour effectuer des comparaisons. Le modèle principal invoque operator == sur des lvalues constantes de type T et nie le résultat. La spécialisation not_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 not_equal_to sont Semiregular .

Table des matières

Types membres

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

Fonctions membres

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

std::experimental::ranges::not_equal_to:: operator()

constexpr bool operator ( ) ( const T & x, const T & y ) const ;
(1) (membre uniquement du template principal not_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 natif comparant des pointeurs */

constexpr bool operator ( ) ( T && t, U && u ) const ;
(2) (membre uniquement de la spécialisation not_equal_to<void> )
1) Compare x et y . Équivalent à return ! ranges:: equal_to <> { } ( x, y ) ; .
2) Compare t et u . Équivalent à return ! ranges:: equal_to <> { } ( std:: forward < T > ( t ) , std:: forward < U > ( u ) ) ; .

Notes

Contrairement à std::not_equal_to , ranges::not_equal_to exige que les deux opérateurs == et != soient valides (via les contraintes EqualityComparable et EqualityComparableWith ), et est entièrement défini en termes de ranges::equal_to . Cependant, l'implémentation est libre d'utiliser directement operator ! = , car ces concepts exigent que les résultats de == et != soient cohérents.

Exemple

Voir aussi

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