std::cmp_equal, cmp_not_equal, cmp_less, cmp_greater, cmp_less_equal, cmp_greater_equal
| 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) |
Compare les valeurs de deux entiers t et u. Contrairement aux opérateurs de comparaison natifs, les entiers signés négatifs sont toujours comparés comme inférieurs à (et non égaux à) des entiers non signés : la comparaison est sûre contre les conversions d'entiers non préservant la valeur.
-1 > 0u; // true
std::cmp_greater(-1, 0u); // false
C'est une erreur de compilation si T ou U est d'un type non entier, d'un type caractère, ou bool.
Paramètres
| t | - | argument de gauche |
| u | - | argument de droite |
Valeur de retour
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
).
#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) |