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

 

C++

Sprache

Concepts

Utilities-Bibliothek

Strings Bibliothek

Container-Bibliothek

Algorithmen-Bibliothek

Iteratoren Bibliothek

Numerik-Bibliothek

Input / Output-Bibliothek

Lokalisierungen Bibliothek

Reguläre Ausdrücke Bibliothek (C++11)

Atomare Operationen Bibliothek (C++11)

Thread Support-Bibliothek (C++11)

 

Utilities-Bibliothek

Typen Unterstützung (basic types, RTTI, type traits)

Dynamische Speicherverwaltung

Fehlerbehandlung

Programm Unterstützung

Variadic Funktionen

Datum und Uhrzeit

Funktionsobjekte

initializer_list (C++11)

bitset

hash (C++11)

Relationale Operatoren

rel_ops::operator!= rel_ops::operator> rel_ops::operator<= rel_ops::operator>=

Paare und Tupel

pair

tuple (C++11)

piecewise_construct_t (C++11)

piecewise_construct (C++11)

Swap, forward und move

swap

forward (C++11)

move (C++11)

move_if_noexcept (C++11)

declval (C++11)

 

<tbody> </tbody>

definiert in Header <Hilfsfunktionen>
template< class T, class U > constexpr bool cmp_equal( T t, U u ) noexcept;	(1)
template< class T, class U > constexpr bool cmp_not_equal( T t, U u ) noexcept;	(2)
template< class T, class U > constexpr bool cmp_less( T t, U u ) noexcept;	(3)
template< class T, class U > constexpr bool cmp_greater( T t, U u ) noexcept;	(4)
template< class T, class U > constexpr bool cmp_less_equal( T t, U u ) noexcept;	(5)
template< class T, class U > constexpr bool cmp_greater_equal( T t, U u ) noexcept;	(6)

See More

Vergleicht zwei ganzahlige Werte t und u. Anders als eingebaute Vergleichsoperatoren werden negative, vorzeichenbehaftete Ganzzahlen immer als kleiner als (und nicht gleich zu) in Bezug auf nicht-vorzeichenbehaftete Ganzzahlen angegeben. Der Vergleich ist sicher bezüglich verlustbehafteter Ganzzahlenkonvertierung.

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

Es führt zu einem Kompilationsfehler, falls entweder T oder U kein nicht-vorzeichen- oder vorzeigenbehaftete Ganzzahltyp ist. Dieses schließt Ganzzahlen des Standards und erweiterte Ganzzahlen ein.

Parameter

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

Rückgabewerte

1) true falls t gleich zu u ist.

2) true falls t ungleich zu u ist.

3) true falls t kleiner als u ist.

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

5) true falls t kleiner als oder gleich zu u ist.

6) true falls t größer als oder gleich zu u ist.

Mögliche Implementierungen

template< class T, class U > constexpr bool cmp_equal( T t, U u ) noexcept { using UT = std::make_unsigned_t<T>; using UU = std::make_unsigned_t<U>; 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 ? false : UT(t) == u; else return u < 0 ? false : t == UU(u); } 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 { using UT = std::make_unsigned_t<T>; using UU = std::make_unsigned_t<U>; 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 ? true : UT(t) < u; else return u < 0 ? false : t < UU(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_greater(t, u); } template< class T, class U > constexpr bool cmp_greater_equal( T t, U u ) noexcept { return !cmp_less(t, u); }

Anmerkungen

Diese Funktionen können nicht benutzt werden, um enums (einschließlich std::byte), char, char8_t, char16_t, char32_t, wchar_t oder bool zu vergleichen.

Feature testing macro: __cpp_lib_integer_comparison_functions

Beispiele

Das Beispiele unten könnte Warnungen über different signedness comparison erzeugen, falls es nicht mit entsprechender Warnungsunterdrückung kompiliert wird, wie z.B. -Wno-sign-compare (gcc/clang mit -Wall -Wextra, siehe auch SO: disabling a specific warning).

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

Referenzen

equal_to	Funktions-Objekt Umsetzung x == y Original: function object implementing x == y The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (Klassen-Template)
not_equal_to	Funktions-Objekt Umsetzung x != y Original: function object implementing x != y The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (Klassen-Template)
less	Funktions-Objekt Umsetzung x < y Original: function object implementing x < y The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (Klassen-Template)
greater	Funktions-Objekt Umsetzung x > y Original: function object implementing x > y The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (Klassen-Template)
less_equal	Funktions-Objekt Umsetzung x <= y Original: function object implementing x <= y The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (Klassen-Template)
greater_equal	Funktions-Objekt Umsetzung x >= y Original: function object implementing x >= y The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (Klassen-Template)
ranges::equal_to (C++20)	Funktionsojekt, daß x = y implementiert (Klasse)
ranges::not_equal_to (C++20)	Funktionsojekt, daß x != y implementiert (Klasse)
ranges::less (C++20)	Funktionsojekt, daß x < y implementiert (Klasse)
ranges::greater (C++20)	Funktionsojekt, daß x > y implementiert (Klasse)
ranges::less_equal (C++20)	Funktionsojekt, daß x <= y implementiert (Klasse)
ranges::greater_equal (C++20)	Funktionsojekt, daß x >= y implementiert (Klasse)
compare_three_way (C++20)	Funktionsobjekt, daß x <=> y implementiert (Klasse)
in_range (C++20)	überprüft, ob ein Ganzzahlwert im Wertebereich eines gegebenen Ganzzahltyps liegt (Funktions-Template)
numeric_limits	bietet eine Schnittstelle zur Abfrage von Eigenschaften aller grundlegenden numerischen Typen . Original: provides an interface to query properties of all fundamental numeric types. The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (Klassen-Template)