Namespaces
Variants

std:: strong_ordering

From cppreference.net
C++
Utilities library
Определено в заголовке <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 имеет четыре допустимых значения, реализованных как константные статические члены данных своего типа:

Название Определение
inline constexpr std :: strong_ordering less
[static]
допустимое значение, указывающее отношение "меньше чем" (упорядочено до)
(публичная статическая константа-член)
inline constexpr std :: strong_ordering equivalent
[static]
допустимое значение, указывающее эквивалентность (не упорядочено до и не упорядочено после), то же самое, что и equal
(публичная статическая константа-член)
inline constexpr std :: strong_ordering equal
[static]
допустимое значение, указывающее эквивалентность (не упорядочено до и не упорядочено после), то же самое, что и equivalent
(публичная статическая константа-член)
inline constexpr std :: strong_ordering 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 и др.

Эти функции не видны при обычном unqualified или qualified lookup , и могут быть найдены только с помощью argument-dependent lookup , когда 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 ? " >  " : " == " ) // сравнивается с 0
              << q << '\n';
}
void print_two_way_comparison(const auto& p, const auto& q)
{
    std::cout << p
              << (p < q ? " <  " : p > q ? " >  " : " == ") // сравнивает p и 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)

Смотрите также

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