std::strong_ordering

Определён в заголовочном файле `<compare>`
class strong_ordering;		(начиная с C++20)

Тип класса std::strong_ordering является типом результата трёхстороннего сравнения, которое:

Поддерживает все шесть операторов отношения (==, !=, <, <=, >, >=).
Обеспечивает взаимозаменяемость: если a эквивалентно b, то f(a) также эквивалентно f(b), где f обозначает функцию, которая читает только значимое для сравнения состояние, доступное через открытые константные члены аргумента. Иными словами, эквивалентные значения неразличимы.
Не допускает несравнимых значений: ровно одно из a < b, a == b или a > b должно быть true.

Константы

Тип std::strong_ordering имеет четыре допустимых значения, реализованных как статические константные члены данных этого типа:

Имя	Определение
less [static]	допустимое значение, обозначающее отношение «меньше» (упорядочено перед) (открытая статическая константа-член)
equivalent [static]	допустимое значение, обозначающее эквивалентность (не упорядочено ни перед, ни после), то же, что и `equal` (открытая статическая константа-член)
equal [static]	допустимое значение, обозначающее эквивалентность (не упорядочено ни перед, ни после), то же, что и `equivalent` (открытая статическая константа-член)
greater [static]	допустимое значение, обозначающее отношение «больше» (упорядочено после) (открытая статическая константа-член)

Преобразования

std::strong_ordering — самая строгая из трёх категорий сравнения: она не преобразуется неявно ни из одной другой категории и неявно преобразуется в две остальные.

operator partial_ordering

неявное преобразование в std::partial_ordering
(открытая функция-член)

std::strong_ordering::operator partial_ordering

constexpr operator partial_ordering() const noexcept;

Возвращаемое значение

std::partial_ordering::less, если v равно less, std::partial_ordering::greater, если v равно greater, std::partial_ordering::equivalent, если v равно equal или equivalent.

operator weak_ordering

неявное преобразование в std::weak_ordering
(открытая функция-член)

std::strong_ordering::operator weak_ordering

constexpr operator weak_ordering() const noexcept;

Возвращаемое значение

std::weak_ordering::less, если v равно less, std::weak_ordering::greater, если v равно greater, std::weak_ordering::equivalent, если v равно equal или equivalent.

Сравнения

Операторы сравнения определены для значений этого типа и литерала 0. Это позволяет использовать выражения a <=> b == 0 или a <=> b < 0 для преобразования результата оператора трёхстороннего сравнения в логическое отношение; см. std::is_eq, std::is_lt и т. д.

Эти функции не видны при обычном поиске неквалифицированного имени или поиске квалифицированного имени; их можно найти только с помощью поиска, зависящего от аргументов, если std::strong_ordering является ассоциированным классом аргументов.

Поведение программы, которая пытается сравнить strong_ordering с чем-либо, кроме целочисленного литерала 0, не определено.

operator==operator<operator>operator<=operator>=operator<=>

сравнение с нулём или strong_ordering
(функция)

operator==

friend constexpr bool operator==( strong_ordering v, /unspecified/ u ) noexcept;	(1)
friend constexpr bool operator==( strong_ordering v, strong_ordering w ) noexcept = default;	(2)

Параметры

v, w	-	значения `std::strong_ordering` для проверки
u	-	неиспользуемый параметр любого типа, допускающий аргумент-литерал ноль

Возвращаемое значение

1) true, если v равно equivalent или equal, false, если v равно less или greater

2) true, если оба параметра содержат одинаковое значение, в противном случае false. Обратите внимание, что equal — это то же самое, что equivalent.

operator<

friend constexpr bool operator<( strong_ordering v, /unspecified/ u ) noexcept;	(1)
friend constexpr bool operator<( /unspecified/ u, strong_ordering v ) noexcept;	(2)

Параметры

v	-	значение `std::strong_ordering` для проверки
u	-	неиспользуемый параметр любого типа, допускающий аргумент-литерал ноль

Возвращаемое значение

1) true, если v равно less, и false, если v равно greater, equivalent или equal

2) true, если v равно greater, и false, если v равно less, equivalent или equal

operator<=

friend constexpr bool operator<=( strong_ordering v, /unspecified/ u ) noexcept;	(1)
friend constexpr bool operator<=( /unspecified/ u, strong_ordering v ) noexcept;	(2)

Параметры

v	-	значение `std::strong_ordering` для проверки
u	-	неиспользуемый параметр любого типа, допускающий аргумент-литерал ноль

Возвращаемое значение

1) true, если v равно less, equivalent или equal, и false, если v равно greater

2) true, если v равно greater, equivalent или equal, и false, если v равно less

operator>

friend constexpr bool operator>( strong_ordering v, /unspecified/ u ) noexcept;	(1)
friend constexpr bool operator>( /unspecified/ u, strong_ordering v ) noexcept;	(2)

Параметры

v	-	значение `std::strong_ordering` для проверки
u	-	неиспользуемый параметр любого типа, допускающий аргумент-литерал ноль

Возвращаемое значение

1) true, если v равно greater, и false, если v равно less, equivalent или equal

2) true, если v равно less, и false, если v равно greater, equivalent или equal

operator>=

friend constexpr bool operator>=( strong_ordering v, /unspecified/ u ) noexcept;	(1)
friend constexpr bool operator>=( /unspecified/ u, strong_ordering v ) noexcept;	(2)

Параметры

v	-	значение `std::strong_ordering` для проверки
u	-	неиспользуемый параметр любого типа, допускающий аргумент-литерал ноль

Возвращаемое значение

1) true, если v равно greater, equivalent или equal, и false, если v равно less

2) true, если v равно less, equivalent или equal, и false, если v равно greater

operator<=>

friend constexpr strong_ordering operator<=>( strong_ordering v, /unspecified/ u ) noexcept;	(1)
friend constexpr strong_ordering operator<=>( /unspecified/ u, strong_ordering v ) noexcept;	(2)

Параметры

v	-	значение `std::strong_ordering` для проверки
u	-	неиспользуемый параметр любого типа, допускающий аргумент-литерал ноль

Возвращаемое значение

1) v.

2) greater, если v равно less, less, если v равно greater, в противном случае v.

Пример

#include <compare>
#include <iostream>

struct Point
{
    int x{}, y{};

    friend constexpr std::strong_ordering operator<=>(Point lhs, Point rhs)
    {
        if (lhs.x < rhs.x or (lhs.x == rhs.x and lhs.y < rhs.y))
            return std::strong_ordering::less;
        if (lhs.x > rhs.x or (lhs.x == rhs.x and lhs.y > rhs.y))
            return std::strong_ordering::greater;
        return std::strong_ordering::equivalent;
    }

    friend std::ostream& operator<<(std::ostream& os, Point s)
    {
        return os << '(' << s.x << ',' << s.y << ')';
    }
};

void print_three_way_comparison(const auto& p, const auto& q)
{
    const auto cmp{p <=> q};
    std::cout << p
              << (cmp < 0 ? " <  " : cmp > 0 ? " >  " : " == " ) // compares with 0
              << q << '\n';
}

void print_two_way_comparison(const auto& p, const auto& q)
{
    std::cout << p
              << (p < q ? " <  " : p > q ? " >  " : " == ") // compares p and q
              << q << '\n';
}

int main()
{
    const Point p1{0, 1}, p2{0, 1}, p3{0, 2};

    print_three_way_comparison(p1, p2);
    print_two_way_comparison(p1, p2);

    print_three_way_comparison(p2, p3);
    print_two_way_comparison(p2, p3);

    print_three_way_comparison(p3, p2);
    print_two_way_comparison(p3, p2);
}

Вывод:

(0,1) == (0,1)
(0,1) == (0,1)
(0,1) <  (0,2)
(0,1) <  (0,2)
(0,2) >  (0,1)
(0,2) >  (0,1)

См. также

weak_ordering (C++20)	тип результата трёхстороннего сравнения, поддерживающий все 6 операторов и не обеспечивающий взаимозаменяемость (класс)
partial_ordering (C++20)	тип результата трёхстороннего сравнения, поддерживающий все 6 операторов, не обеспечивающий взаимозаменяемость и допускающий несравнимые значения (класс)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/utility/compare/strong_ordering