std::totally_ordered, std::totally_ordered_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

 

Konzeptbibliothek

Kernsprachen-Konzepte same_as (C++20) derived_from (C++20) convertible_to (C++20) common_reference_with (C++20) common_with (C++20) integral (C++20) signed_integral (C++20) unsigned_integral (C++20) floating_point (C++20) swappableswappable_with (C++20)(C++20) destructible (C++20) constructible_from (C++20) default_initializable (C++20)   move_constructible (C++20) copy_constructible (C++20) assignable_from (C++20)

Vergleichskonzepte equality_comparableequality_comparable_with (C++20)(C++20) totally_orderedtotally_ordered_with (C++20)(C++20) Objektkonzepte movable (C++20) copyable (C++20) semiregular (C++20) regular (C++20) Aufrufbare Konzepte invocableregular_invocable (C++20)(C++20) predicate (C++20) relation (C++20) equivalence_relation (C++20) strict_weak_order (C++20)

Exposition-only Konzepte boolean-testable  (C++20)

 

Definiert in der Header-Datei <concepts>
template< class T > Konzept totally_ordered =     std::equality_comparable<T> && __PartiallyOrderedWith<T, T>;	(1)	(seit C++20)
template< class T, class U > Konzept totally_ordered_with =     std::totally_ordered<T> &&     std::totally_ordered<U> &&     std::equality_comparable_with<T, U> &&     std::totally_ordered<         std::common_reference_t<             const std::remove_reference_t<T>&,             const std::remove_reference_t<U>&>> &&     __PartiallyOrderedWith<T, U>;	(2)	(seit C++20)
Hilfskonzepte
template< class T, class U > Konzept __PartiallyOrderedWith =     requires(const std::remove_reference_t<T>& t,              const std::remove_reference_t<U>& u) {         { t <  u } -> boolean-testable;         { t >  u } -> boolean-testable;         { t <= u } -> boolean-testable;         { t >= u } -> boolean-testable;         { u <  t } -> boolean-testable;         { u >  t } -> boolean-testable;         { u <= t } -> boolean-testable;         { u >= t } -> boolean-testable;     };	(3)	(nur Exposition*)

1) Das Konzept std::totally_ordered spezifiziert, dass die Vergleichsoperatoren ==,!=,<,>,<=,>= eines Typs Ergebnisse liefern, die mit einer strikt totalen Ordnung auf dem Typ konsistent sind.

2) Das Konzept std::totally_ordered_with spezifiziert, dass die Vergleichsoperatoren ==,!=,<,>,<=,>= auf (möglicherweise gemischten) Operanden vom Typ T und U Ergebnisse liefern, die mit einer strikten totalen Ordnung konsistent sind. Der Vergleich gemischter Operanden liefert Ergebnisse, die äquivalent zum Vergleich der Operanden sind, die in ihren gemeinsamen Typ konvertiert wurden.

3) Das expositions-nur-Konzept __PartiallyOrderedWith spezifiziert, dass ein Wert vom Typ T und ein Wert vom Typ U in einer partiellen Ordnung miteinander verglichen werden können (in beliebiger Reihenfolge) unter Verwendung von <, >, <= und >=, und die Ergebnisse der Vergleiche konsistent sind.

Semantische Anforderungen

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

1) std::totally_ordered<T> wird nur dann modelliert, wenn für Lvalues a, b und c vom Typ const std::remove_reference_t<T>

• Genau einer der Ausdrücke bool(a < b), bool(a > b) und bool(a == b) ist true;
• Wenn bool(a < b) und bool(b < c) beide true sind, dann ist bool(a < c) true;
• bool(a > b) == bool(b < a)
• bool(a >= b) == !bool(a < b)
• bool(a <= b) == !bool(b < a)

2) std::totally_ordered_with<T, U> wird nur dann modelliert, wenn gegeben

• t und t2, Lvalues, die unterschiedliche, gleiche Objekte der Typen const std::remove_reference_t<T> und std::remove_reference_t<T> bezeichnen, und
• u und u2, Lvalues, die unterschiedliche, 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

• bool(t < u) == bool(CONVERT_TO<C>(t2) < CONVERT_TO<C>(u2))
• bool(t > u) == bool(CONVERT_TO<C>(t2) > CONVERT_TO<C>(u2))
• bool(t <= u) == bool(CONVERT_TO<C>(t2) <= CONVERT_TO<C>(u2))
• bool(t >= u) == bool(CONVERT_TO<C>(t2) >= CONVERT_TO<C>(u2))
• bool(u < t) == bool(CONVERT_TO<C>(u2) < CONVERT_TO<C>(t2))
• bool(u > t) == bool(CONVERT_TO<C>(u2) > CONVERT_TO<C>(t2))
• bool(u <= t) == bool(CONVERT_TO<C>(u2) <= CONVERT_TO<C>(t2))
• bool(u >= t) == bool(CONVERT_TO<C>(u2) >= CONVERT_TO<C>(t2))

3) __PartiallyOrderedWith<T, U> wird nur dann modelliert, wenn gegeben

• jedes Lvalue t vom Typ const std::remove_reference_t<T>, und
• jedes Lvalue u vom Typ const std::remove_reference_t<U>,

die folgenden Bedingungen erfüllt sind

• t < u, t <= u, t > u, t >= u, u < t, u <= t, u > t, und u >= t denselben Definitionsbereich haben;
• bool(t < u) == bool(u > t);
• bool(u < t) == bool(t > u);
• bool(t <= u) == bool(u >= t); und
• bool(u <= t) == bool(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.

Referenzen

• C++23 Standard (ISO/IEC 14882:2024)

• 18.5.5 Konzept totally_ordered [concept.totallyordered]

• C++20 Standard (ISO/IEC 14882:2020)

• 18.5.4 Konzept totally_ordered [concept.totallyordered]

Siehe auch

three_way_comparablethree_way_comparable_with (C++20)

gibt an, dass der Operator <=> konsistente Ergebnisse für die gegebenen Typen liefert (Konzept)