Namespaces
Variants

std::experimental::ranges:: less_equal

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

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

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

Fonction objet pour effectuer des comparaisons. Le modèle principal invoque operator < sur des lvalues constantes de type T avec l'ordre des arguments inversé puis nie le résultat. La spécialisation less_equal<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 less_equal sont Semiregular .

Table des matières

Types membres

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

Fonctions membres

operator()
vérifie si le premier argument est inférieur ou égal au second
(fonction membre publique)

std::experimental::ranges::less_equal:: operator()

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

requires StrictTotallyOrderedWith < 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 less_equal<void> )
1) Compare x et y . Équivalent à return ! ranges:: less <> { } ( y, x ) ; .
2) Compare t et u . Équivalent à return ! ranges:: less <> { } ( std:: forward < U > ( u ) , std:: forward < T > ( t ) ) ; .

Notes

Contrairement à std::less_equal , ranges::less_equal exige que les six opérateurs de comparaison < , <= , > , >= , == et != soient valides (via les contraintes StrictTotallyOrdered et StrictTotallyOrderedWith ) et est entièrement défini en termes de ranges::less . Cependant, l'implémentation est libre d'utiliser operator <= directement, car ces concepts exigent que les résultats des opérateurs de comparaison soient cohérents.

Exemple

Voir aussi

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