std::three_way_comparable, std::three_way_comparable_with

 

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 <compare>
template< class T, class Cat = std::partial_ordering > concept three_way_comparable =     __WeaklyEqualityComparableWith<T, T> &&     __PartiallyOrderedWith<T, T> &&     requires(const std::remove_reference_t<T>& a,              const std::remove_reference_t<T>& b) {         { a <=> b } -> __ComparesAs<Cat>;     };	(1)	(seit C++20)
template< class T, class U, class Cat = std::partial_ordering > concept three_way_comparable_with =     std::three_way_comparable<T, Cat> &&     std::three_way_comparable<U, Cat> &&     __ComparisonCommonTypeWith<T, U> &&     std::three_way_comparable<         std::common_reference_t<             const std::remove_reference_t<T>&,             const std::remove_reference_t<U>&>, Cat> &&     __WeaklyEqualityComparableWith<T, U> &&     __PartiallyOrderedWith<T, U> &&     requires(const std::remove_reference_t<T>& t,              const std::remove_reference_t<U>& u) {         { t <=> u } --> __ComparesAs<Cat>;         { u <=> t } --> __ComparesAs<Cat>;     };	(2)	(seit C++20)
template< class T, class Cat > concept __ComparesAs =     std::same_as<std::common_comparison_category_t<T, Cat>, Cat>;	(3)	(nur Exposition*)

1) Das Konzept std::three_way_comparable gibt an, dass der Drei-Wege-Vergleichsoperator <=> auf T Ergebnisse liefert, die mit der durch Cat implizierten Vergleichskategorie konsistent sind.

2) Das Konzept std::three_way_comparable_with gibt an, dass der Drei-Wege-Vergleichsoperator <=> auf (möglicherweise gemischten) Operanden T und U Ergebnisse liefert, die mit der durch Cat implizierten Vergleichskategorie konsistent sind. Der Vergleich von gemischten Operanden liefert Ergebnisse, die mit dem Vergleich der Operanden, die in ihren gemeinsamen Typ konvertiert wurden, äquivalent sind.

__WeaklyEqualityComparableWith, __PartiallyOrderedWith und __ComparisonCommonTypeWith sind Konzepte nur zur Veranschaulichung. Siehe Beschreibungen von equality_comparable und totally_ordered.

Semantische Anforderungen

Diese Konzepte werden nur modelliert, wenn sie erfüllt sind und alle Konzepte, die sie umfassen, modelliert sind.

1) T und Cat modellieren std::three_way_comparable<T, Cat> nur, wenn für L-Werte a und b vom Typ const std::remove_reference_t<T>, Folgendes gilt:

• (a <=> b == 0) == bool(a == b),
• (a <=> b != 0) == bool(a != b),
• ((a <=> b) <=> 0) und (0 <=> (b <=> a)) sind gleich,
• bool(a > b) == bool(b < a),
• bool(a >= b) == !bool(a < b),
• bool(a <= b) == !bool(b < a),
• (a <=> b < 0) == bool(a < b),
• (a <=> b > 0) == bool(a > b),
• (a <=> b <= 0) == bool(a <= b), und
• (a <=> b >= 0) == bool(a >= b), und
• wenn Cat in std::strong_ordering konvertierbar ist, modelliert T totally_ordered.

2) T, U und Cat modellieren std::three_way_comparable_with<T, U, Cat> nur, wenn gegeben

• t und t2, L-Werte, die sich auf verschiedene gleiche Objekte der Typen const std::remove_reference_t<T> und std::remove_reference_t<T> bezeichnen, und
• u und u2, L-Werte, die sich auf verschiedene gleiche Objekte der Typen const std::remove_reference_t<U> und std::remove_reference_t<U> bezeichnen.

Sei C std::common_reference_t<const std::remove_reference_t<T>&, const std::remove_reference_t<U>&> und sei für einen Ausdruck E und einen Typ C CONVERT_TO<C>(E):

static_cast<C>(std::as_const(E)).	(bis C++23)
static_cast<const C&>(std::as_const(E)), falls dies ein gültiger Ausdruck ist, static_cast<const C&>(std::move(E)) andernfalls.	(seit C++23)

die folgenden Bedingungen erfüllt sind

• t <=> u und u <=> t haben denselben Definitionsbereich,
• ((t <=> u) <=> 0) und (0 <=> (u <=> t)) sind gleich,
• (t <=> u == 0) == bool(t == u),
• (t <=> u != 0) == bool(t != u),
• Cat(t <=> u) == Cat(CONVERT_TO<C>(t2) <=> CONVERT_TO<C>(u2)),
• (t <=> u < 0) == bool(t < u),
• (t <=> u > 0) == bool(t > u),
• (t <=> u <= 0) == bool(t <= u),
• (t <=> u >= 0) == bool(t >= u), und
• wenn Cat in std::strong_ordering konvertierbar ist, modellieren T und U std::totally_ordered_with<T, U>.

Gleichheitserhaltung

Ausdrücke, die in requires-Ausdrücken der Standardbibliothekskonzepte deklariert sind, müssen gleichheitserhaltend sein (sofern nicht anders angegeben).

Implizite Ausdrucksvariationen

Ein requires-Ausdruck, der einen Ausdruck verwendet, der für einen konstanten Lvalue-Operanden nicht-modifizierend ist, erfordert ebenfalls implizite Ausdrucksvariationen.

Siehe auch

equality_comparableequality_comparable_with (C++20)	gibt an, dass der Operator == eine Äquivalenzrelation ist (Konzept)
totally_orderedtotally_ordered_with (C++20)	gibt an, dass die Vergleichsoperatoren des Typs eine Totalordnung ergeben (Konzept)