Namespaces
Variants

std:: cmp_equal, cmp_not_equal, cmp_less, cmp_greater, cmp_less_equal, cmp_greater_equal

From cppreference.net
C++
Utilities library
General utilities
Relational operators (deprecated in C++20)
Integer comparison functions
cmp_equal cmp_less cmp_less_than
(C++20) (C++20) (C++20)
cmp_not_equal cmp_greater cmp_greater_than
(C++20) (C++20) (C++20)
(C++20)
Swap and type operations
Common vocabulary types
(C++11)
(C++17)
(C++17)
(C++17)


Défini dans l'en-tête <utility>
template < class T, class U >
constexpr bool cmp_equal ( T t, U u ) noexcept ;
(1) (depuis C++20)
template < class T, class U >
constexpr bool cmp_not_equal ( T t, U u ) noexcept ;
(2) (depuis C++20)
template < class T, class U >
constexpr bool cmp_less ( T t, U u ) noexcept ;
(3) (depuis C++20)
template < class T, class U >
constexpr bool cmp_greater ( T t, U u ) noexcept ;
(4) (depuis C++20)
template < class T, class U >
constexpr bool cmp_less_equal ( T t, U u ) noexcept ;
(5) (depuis C++20)
template < class T, class U >
constexpr bool cmp_greater_equal ( T t, U u ) noexcept ;
(6) (depuis C++20)

Comparez les valeurs de deux entiers t et u . Contrairement aux opérateurs de comparaison intégrés, les entiers signés négatifs comparent toujours moins que (et pas égal à ) les entiers non signés : la comparaison est sûre contre la conversion d'entier non préservant la valeur. 

-1 > 0u; // vrai
std::cmp_greater(-1, 0u); // faux

C'est une erreur de compilation si soit T soit U est un type non- entier , un type caractère, ou bool .

Table des matières

Paramètres

t - argument de gauche
u - argument de droite

Valeur de retour

1) true si t est égal à u .
2) true si t n'est pas égal à u .
3) true si t est inférieur à u .
4) true si t est supérieur à u .
5) true si t est inférieur ou égal à u .
6) true si t est supérieur ou égal à u .

Implémentation possible 

template<class T, class U>
constexpr bool cmp_equal(T t, U u) noexcept
{
    if constexpr (std::is_signed_v<T> == std::is_signed_v<U>)
        return t == u;
    else if constexpr (std::is_signed_v<T>)
        return t >= 0 && std::make_unsigned_t<T>(t) == u;
    else
        return u >= 0 && std::make_unsigned_t<U>(u) == t;
}
template<class T, class U>
constexpr bool cmp_not_equal(T t, U u) noexcept
{
    return !cmp_equal(t, u);
}
template<class T, class U>
constexpr bool cmp_less(T t, U u) noexcept
{
    if constexpr (std::is_signed_v<T> == std::is_signed_v<U>)
        return t < u;
    else if constexpr (std::is_signed_v<T>)
        return t < 0 || std::make_unsigned_t<T>(t) < u;
    else
        return u >= 0 && t < std::make_unsigned_t<U>(u);
}
template<class T, class U>
constexpr bool cmp_greater(T t, U u) noexcept
{
    return cmp_less(u, t);
}
template<class T, class U>
constexpr bool cmp_less_equal(T t, U u) noexcept
{
    return !cmp_less(u, t);
}
template<class T, class U>
constexpr bool cmp_greater_equal(T t, U u) noexcept
{
    return !cmp_less(t, u);
}

Notes

Ces fonctions ne peuvent pas être utilisées pour comparer les énumérations (y compris std::byte ), char , char8_t , char16_t , char32_t , wchar_t et bool .

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_integer_comparison_functions 202002L (C++20) Fonctions de comparaison d'entiers

Exemple

L'exemple ci-dessous pourrait produire un avertissement de comparaison de signes différents s'il est compilé sans un drapeau de suppression d'avertissement approprié, par exemple, -Wno-sign-compare (gcc/clang avec -Wall -Wextra , voir aussi SO: désactiver un avertissement spécifique ).

Exécuter ce code 
#include <utility>
// Uncommenting the next line will disable "signed/unsigned comparison" warnings:
// #pragma GCC diagnostic ignored "-Wsign-compare"
int main()
{
    static_assert(sizeof(int) == 4); // precondition
    // Quite surprisingly
    static_assert(-1 > 1U); //< warning: sign-unsign comparison
    // because after implicit conversion of -1 to the RHS type (`unsigned int`)
    // the expression is equivalent to:
    static_assert(0xFFFFFFFFU > 1U);
    static_assert(0xFFFFFFFFU == static_cast<unsigned>(-1));
    // In contrast, the cmp_* family compares integers as most expected -
    // negative signed integers always compare less than unsigned integers:
    static_assert(std::cmp_less(-1, 1U));
    static_assert(std::cmp_less_equal(-1, 1U));
    static_assert(!std::cmp_greater(-1, 1U));
    static_assert(!std::cmp_greater_equal(-1, 1U));
    static_assert(-1 == 0xFFFFFFFFU); //< warning: sign-unsign comparison
    static_assert(std::cmp_not_equal(-1, 0xFFFFFFFFU));
}

Voir aussi

objet fonction implémentant x == y
(modèle de classe)
objet fonction implémentant x ! = y
(modèle de classe)
objet fonction implémentant x < y
(modèle de classe)
objet fonction implémentant x > y
(modèle de classe)
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)
(C++20)
objet fonction contraint implémentant x ! = y
(classe)
(C++20)
objet fonction contraint implémentant x < y
(classe)
(C++20)
objet fonction contraint implémentant x > y
(classe)
(C++20)
objet fonction contraint implémentant x <= y
(classe)
(C++20)
objet fonction contraint implémentant x >= y
(classe)
(C++20)
objet fonction contraint implémentant x <=> y
(classe)
(C++20)
vérifie si une valeur entière est dans l'intervalle d'un type entier donné
(modèle de fonction)
fournit une interface pour interroger les propriétés de tous les types numériques fondamentaux
(modèle de classe)