Namespaces
Variants

std::experimental::ranges:: greater_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 greater_equal ;
(ranges TS)
template <>
struct greater_equal < void > ;
(ranges TS)

Objet fonction 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 greater_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 greater_equal sont Semiregular .

Table des matières

Types membres

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

Fonctions membres

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

std::experimental::ranges::greater_equal:: operator()

constexpr bool operator ( ) ( const T & x, const T & y ) const ;
(1) (membre uniquement du template primaire greater_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 greater_equal<void> )
1) Compare x et y . Équivalent à return ! ranges:: less <> { } ( x, y ) ; .
2) Compare t et u . Équivalent à return ! ranges:: less <> { } ( std:: forward < T > ( t ) , std:: forward < U > ( u ) ) ; .

Notes

Contrairement à std::greater_equal , ranges::greater_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)