std::three_way_comparable, std::three_way_comparable_with

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

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

template< class T, class Cat >
concept __ComparesAs =
    std::same_as<std::common_comparison_category_t<T, Cat>, Cat>;

1) Das Konzept std::three_way_comparable gibt an, dass der Dreifachvergleichsoperator <=> 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 Dreifachvergleichsoperator <=> auf (möglicherweise gemischten) T- und U-Operanden Ergebnisse liefert, die mit der durch Cat implizierten Vergleichskategorie konsistent sind. Das Vergleichen gemischter Operanden liefert Ergebnisse, die dem Vergleichen der in ihren gemeinsamen Typ konvertierten Operanden entsprechen.

1) T und Cat modellieren std :: three_way_comparable < T, Cat > nur dann, wenn für Lvalues a und b vom Typ const std:: remove_reference_t < T > Folgendes zutrifft:

• ( a <=> b == 0 ) == bool ( a == b ) ,
• ( a <=> b ! = 0 ) == bool ( a ! = b ) ,
• ( ( a <=> b ) <=> 0 ) und ( 0 <=> ( b <=> a ) ) gleich sind,
• 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
• falls Cat konvertierbar zu std::strong_ordering ist, T modelliert totally_ordered .

2) T , U , and Cat model std :: three_way_comparable_with < T, U, Cat > only if given

• 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 definiert als std:: common_reference_t < const std:: remove_reference_t < T > & , const std:: remove_reference_t < U > & > und für einen gegebenen Ausdruck E und einen Typ C sei CONVERT_TO < C > ( E ) definiert als:

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)

Folgendes trifft zu:

• 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
• falls Cat konvertierbar zu std::strong_ordering ist, modellieren T und U std:: totally_ordered_with < T, U > .