Namespaces
Variants

std:: less

From cppreference.net
C++
Utilities library
Function objects
Function invocation
(C++17) (C++23)
Identity function object
(C++20)
Old binders and adaptors
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* ) ( until C++17* ) ( until C++17* ) ( until C++17* )
( until C++20* )
( until C++20* )
( until C++17* ) ( until C++17* )
( until C++17* ) ( until C++17* )

( until C++17* )
( until C++17* ) ( until C++17* ) ( until C++17* ) ( until C++17* )
( until C++20* )
( until C++20* )
Défini dans l'en-tête <functional>
template < class T >
struct less ;
(jusqu'en C++14)
template < class T = void >
struct less ;
(depuis C++14)

Objet fonction pour effectuer des comparaisons. Le modèle principal invoque operator < sur le type T .

Table des matières

Spécialisations

(C++14)
objet fonction implémentant x < y avec déduction des types de paramètres et de retour
(spécialisation de modèle de classe)

Types membres

Type Définition
result_type (obsolète en C++17) (supprimé en C++20) bool
first_argument_type (obsolète en C++17) (supprimé en C++20) T
second_argument_type (obsolète en C++17) (supprimé en C++20) T

Ces types membres sont obtenus via l'héritage public de std:: binary_function < T, T, bool > .

(jusqu'à C++11)

Fonctions membres

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

std::less:: operator()

bool operator ( ) ( const T & lhs, const T & rhs ) const ;
(constexpr depuis C++14)

Vérifie si lhs est inférieur à rhs .

Paramètres

lhs, rhs - valeurs à comparer

Valeur de retour

lhs < rhs .

Si T est un type pointeur, le résultat est cohérent avec l'ordre total strict défini par l'implémentation sur les pointeurs .

Exceptions

Peut lever des exceptions définies par l'implémentation.

Implémentation possible 

constexpr bool operator()(const T& lhs, const T& rhs) const 
{
    return lhs < rhs; // assumes that the implementation handles pointer total order
}

Exemple

Exécuter ce code 
#include <functional>
template<typename A, typename B, typename C = std::less<>>
constexpr bool fun(A a, B b, C cmp = C{})
{
    return cmp(a, b);
}
static_assert(fun(1, 2) == true);
static_assert(fun(1.0, 1) == false);
static_assert(fun(1, 2.0) == true);
static_assert(std::less<int>{}(5, 5.6) == false);   // 5 < 5 (avertissement : conversion implicite)
static_assert(std::less<double>{}(5, 5.6) == true); // 5.0 < 5.6
static_assert(std::less<int>{}(5.6, 5.7) == false); // 5 < 5 (avertissement : conversion implicite)
static_assert(std::less{}(5, 5.6) == true);         // less<void>: 5.0 < 5.6
int main() {}

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement correct
LWG 2562 C++98 l'ordre total des pointeurs pourrait être incohérent garanti d'être cohérent

Voir aussi

objet fonction implémentant x == y
(modèle de classe)
objet fonction implémentant x > y
(modèle de classe)
(C++20)
objet fonction contraint implémentant x < y
(classe)