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

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Dienstprogramm-Bibliotheken

Sprachunterstützung Typunterstützung (Basistypen, RTTI) Bibliotheks-Feature-Test-Makros (C++20) Programm-Dienstprogramme Variadische Funktionen initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Coroutine-Unterstützung (C++20) Vertragsunterstützung (C++26) Drei-Wege-Vergleich three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Allgemeine Hilfsmittel Funktionsobjekte Bit-Manipulation (C++20) bitset hash (C++11) Relationale Operatoren (in C++20 veraltet) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Ganzzahl-Vergleichsfunktionen cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap und Typ-Operationen swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Gemeinsame Vokabulartypen pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

Definiert in der Header-Datei <utility>
template< class T, class U > constexpr bool cmp_equal( T t, U u ) noexcept;	(1)	(seit C++20)
template< class T, class U > constexpr bool cmp_not_equal( T t, U u ) noexcept;	(2)	(seit C++20)
template< class T, class U > constexpr bool cmp_less( T t, U u ) noexcept;	(3)	(seit C++20)
template< class T, class U > constexpr bool cmp_greater( T t, U u ) noexcept;	(4)	(seit C++20)
template< class T, class U > constexpr bool cmp_less_equal( T t, U u ) noexcept;	(5)	(seit C++20)
template< class T, class U > constexpr bool cmp_greater_equal( T t, U u ) noexcept;	(6)	(seit C++20)

Vergleicht die Werte zweier Ganzzahlen t und u. Im Gegensatz zu integrierten Vergleichsoperatoren sind negative vorzeichenbehaftete Ganzzahlen immer kleiner als (und nicht gleich) vorzeichenlose Ganzzahlen: der Vergleich ist sicher gegen nicht werterhaltende Ganzzahlkonvertierungen.

-1 > 0u; // true
std::cmp_greater(-1, 0u); // false

Es ist ein Kompilierungsfehler, wenn entweder T oder U ein nicht-Ganzzahltyp, ein Zeichentyp oder bool ist.

Parameter

t	-	Argument auf der linken Seite
u	-	Argument auf der rechten Seite

Rückgabewert

1) true, wenn t gleich u ist.

2) true, wenn t nicht gleich u ist.

3) true, wenn t kleiner als u ist.

4) true, wenn t größer als u ist.

5) true, wenn t kleiner oder gleich u ist.

6) true, wenn t größer oder gleich u ist.

Mögliche Implementierung

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); }

Hinweise

Diese Funktionen können nicht zum Vergleichen von Aufzählungen (einschließlich std::byte), char, char8_t, char16_t, char32_t, wchar_t und bool verwendet werden.

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_integer_comparison_functions	202002L	(C++20)	Ganzzahl-Vergleichsfunktionen

Beispiel

Das folgende Beispiel kann eine Warnung für unterschiedliche Vorzeichenbehaftung beim Vergleichen ausgeben, wenn es ohne ein entsprechendes Flag zur Unterdrückung von Warnungen kompiliert wird, z. B. -Wno-sign-compare (gcc/clang mit -Wall -Wextra, siehe auch SO: disabling a specific warning).

Führen Sie diesen Code aus

#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));
}

Siehe auch

equal_to	Funktions-Objekt, das x == y implementiert (Klassen-Template)
not_equal_to	Funktions-Objekt, das x != y implementiert (Klassen-Template)
less	Funktions-Objekt, das x < y implementiert (Klassen-Template)
greater	Funktions-Objekt, das x > y implementiert (Klassen-Template)
less_equal	Funktions-Objekt, das x <= y implementiert (Klassen-Template)
greater_equal	Funktions-Objekt, das x >= y implementiert (Klassen-Template)
ranges::equal_to (C++20)	Beschränktes Funktionsobjekt, das x == y implementiert (Klasse)
ranges::not_equal_to (C++20)	Beschränktes Funktionsobjekt, das x != y implementiert (Klasse)
ranges::less (C++20)	Beschränktes Funktionsobjekt, das x < y implementiert (Klasse)
ranges::greater (C++20)	Beschränktes Funktionsobjekt, das x > y implementiert (Klasse)
ranges::less_equal (C++20)	Beschränktes Funktionsobjekt, das x <= y implementiert (Klasse)
ranges::greater_equal (C++20)	Beschränktes Funktionsobjekt, das x >= y implementiert (Klasse)
compare_three_way (C++20)	beschränkte Funktionsobjekte, die x <=> y implementieren (Klasse)
in_range (C++20)	prüft, ob ein Ganzzahlwert im Bereich eines gegebenen Ganzzahltyps liegt (Funktionsvorlage)
numeric_limits	bietet eine Schnittstelle zur Abfrage von Eigenschaften aller fundamentalen numerischen Typen (Klassenschablone)