Заголовочный файл стандартной библиотеки <compare> (C++20)

 

C++

Поддержка компилятором

Автономные и размещённые реализации

Язык

Стандартная библиотека

Заголовки стандартной библиотеки

Требования к именованию

Макросы тестирования функциональности (C++20)

Поддержка языка

Библиотека концептов (C++20)

Библиотека метапрограммирования (C++11)

Библиотека диагностики

Библиотека общих утилит

Библиотека строк

Библиотека контейнеров

Библиотека итераторов

Библиотека диапазонов (C++20)

Библиотека алгоритмов

Библиотека численных данных

Библиотека ввода/вывода

Библиотека локализаций

Регулярные выражения (C++11)

Атомарные операции (C++11)

Библиотека поддержки конкуренции (C++11)

Библиотека файловой системы (C++17)

Технические спецификации

Указатель символов

Внешние библиотеки

 

Заголовочные файлы стандартной библиотеки

Языковая поддержка
<cstddef> <cstdlib> <version> (C++20) <limits> <climits>	<cfloat> <cstdint> (C++11) <stdfloat> (C++23) <new> <typeinfo>	<source_location> (C++20) <exception> <initializer_list> (C++11) <compare> (C++20)	<coroutine> (C++20) <csignal> <csetjmp> <cstdarg>
Концепты
<concepts> (C++20)
Диагностика
<stdexcept> <stacktrace> (C++23)	<cassert>	<cerrno>	<system_error> (C++11)
Управление памятью
<memory>	<memory_resource> (C++17)	<scoped_allocator> (C++11)
Метапрограммирование
<type_traits> (C++11)	<ratio> (C++11)
Общие утилиты
<utility> <tuple> (C++11) <optional> (C++17) <variant> (C++17)	<any> (C++17) <expected> (C++23) <bitset>	<functional> <typeindex> (C++11) <execution> (C++17)	<charconv> (C++17) <format> (C++20) <bit> (C++20)
Строки
<string_view> (C++17) <string>	<cctype> <cwctype>	<cstring> <cwchar>	<cuchar> (C++11)
Контейнеры
<array> (C++11) <deque> <forward_list> (C++11) <list>	<vector> <map> <set> <unordered_map> (C++11)	<unordered_set> (C++11) <queue> <stack> <flat_map> (C++23)	<flat_set> (C++23) <span> (C++20) <mdspan> (C++23)
Итераторы
<iterator>
Диапазоны
<ranges> (C++20)	<generator> (C++23)
Алгоритмы
<algorithm>	<numeric>
Числа
<cfenv> (C++11) <complex>	<random> (C++11) <valarray>	<cmath>	<numbers> (C++20)
Время
<chrono> (C++11)	<ctime>
Локализация
<locale>	<clocale>	<codecvt> (C++11/17*)
Ввод/вывод
<iosfwd> <iostream> <ios> <streambuf>	<istream> <ostream> <iomanip> <print> (C++23)	<sstream> <spanstream> (C++23) <fstream> <syncstream> (C++20)	<filesystem> (C++17) <cstdio> <cinttypes> (C++11) <strstream> (C++98*)
Регулярные выражения
<regex> (C++11)
Поддержка конкуренции
<stop_token> (C++20) <thread> (C++11) <atomic> (C++11)	<stdatomic.h> (C++23) <mutex> (C++11) <shared_mutex> (C++14)	<condition_variable> (C++11)   <semaphore> (C++20) <latch> (C++20)	<barrier> (C++20) <future> (C++11)
Совместимость с C
<cstdbool> (C++11/17/20*)   <ccomplex> (C++11/17/20*)	<ctgmath> (C++11/17/20*)	<cstdalign> (C++11/17/20*)	<ciso646> (до C++20)

 

Этот заголовок является частью библиотеки поддержки языка.

Концепты
three_way_comparablethree_way_comparable_with (C++20)	указывает, что оператор <=> даёт согласованный результат для данных типов (концепт)
Классы
partial_ordering (C++20)	тип результата трёхстороннего сравнения, который поддерживает все 6 операторов, невзаимозаменяемый и допускает несравнимые значения (класс)
weak_ordering (C++20)	тип результата трёхстороннего сравнения, который поддерживает все 6 операторов и невзаимозаменяемый (класс)
strong_ordering (C++20)	тип результата трёхстороннего сравнения, который поддерживает все 6 операторов и может быть взаимозаменяемым (класс)
common_comparison_category (C++20)	самая строгая категория сравнения, в которую можно преобразовать все указанные типы (шаблон класса)
compare_three_way_result (C++20)	получает тип результата оператора трёхстороннего сравнения <=> для заданных типов (шаблон класса)
compare_three_way (C++20)	функциональный объект, реализующий x <=> y (класс)
Объекты точек настройки
strong_order (C++20)	выполняет трёхстороннее сравнение и возвращает результат типа std::strong_ordering (объект точки настройки)
weak_order (C++20)	выполняет трёхстороннее сравнение и возвращает результат типа std::weak_ordering (объект точки настройки)
partial_order (C++20)	выполняет трёхстороннее сравнение и возвращает результат типа std::partial_ordering (объект точки настройки)
compare_strong_order_fallback (C++20)	выполняет трёхстороннее сравнение и возвращает результат типа std::strong_ordering, даже если operator<=> недоступен (объект точки настройки)
compare_weak_order_fallback (C++20)	выполняет трёхстороннее сравнение и возвращает результат типа std::weak_ordering, даже если operator<=> недоступен (объект точки настройки)
compare_partial_order_fallback (C++20)	выполняет трёхстороннее сравнение и возвращает результат типа std::partial_ordering, даже если operator<=> недоступен (объект точки настройки)
Функции
is_eqis_neqis_ltis_lteqis_gtis_gteq (C++20)	именованные функции сравнения (функция)

Резюме

namespace std {
  // типы категорий сравнения
  class partial_ordering;
  class weak_ordering;
  class strong_ordering;

  // именованные функции сравнения
  constexpr bool is_eq  (partial_ordering cmp) noexcept { return cmp == 0; }
  constexpr bool is_neq (partial_ordering cmp) noexcept { return cmp != 0; }
  constexpr bool is_lt  (partial_ordering cmp) noexcept { return cmp < 0; }
  constexpr bool is_lteq(partial_ordering cmp) noexcept { return cmp <= 0; }
  constexpr bool is_gt  (partial_ordering cmp) noexcept { return cmp > 0; }
  constexpr bool is_gteq(partial_ordering cmp) noexcept { return cmp >= 0; }

  // общий тип категории сравнения
  template<class... Ts>
  struct common_comparison_category {
    using type = /* смотри описание */;
  };
  template<class... Ts>
    using common_comparison_category_t = typename common_comparison_category<Ts...>::type;

  // концепт three_way_comparable
  template<class T, class Cat = partial_ordering>
    concept three_way_comparable = /* смотри описание */;
  template<class T, class U, class Cat = partial_ordering>
    concept three_way_comparable_with = /* смотри описание */;

  // результат трёхстороннего сравнения
  template<class T, class U = T> struct compare_three_way_result;

  template<class T, class U = T>
    using compare_three_way_result_t = typename compare_three_way_result<T, U>::type;

  // класс compare_three_way
  struct compare_three_way;

  // алгоритмы сравнения
  inline namespace /* не определено */ {
    inline constexpr /* не определено */ strong_order = /* не определено */;
    inline constexpr /* не определено */ weak_order = /* не определено */;
    inline constexpr /* не определено */ partial_order = /* не определено */;
    inline constexpr /* не определено */ compare_strong_order_fallback =
                                                         /* не определено */;
    inline constexpr /* не определено */ compare_weak_order_fallback = /* не определено */;
    inline constexpr /* не определено */ compare_partial_order_fallback =
                                                         /* не определено */;
  }
}

Концепт three_way_comparable

namespace std {
  template<class T, class Cat>
    concept __ComparesAs =                // только экспозиция
      same_as<common_comparison_category_t<T, Cat>, Cat>;

  template<class T, class U>
    concept __PartiallyOrderedWith =      // только экспозиция
      requires(const remove_reference_t<T>& t, const 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;
      };

  template<class T, class Cat = partial_ordering>
    concept three_way_comparable =
      __WeaklyEqualityComparableWith<T, T> &&
      __PartiallyOrderedWith<T, T> &&
      requires(const remove_reference_t<T>& a, const remove_reference_t<T>& b) {
        { a <=> b } -> __ComparesAs<Cat>;
      };
}

Концепт three_way_comparable_with

namespace std {
  template<class T, class U, class Cat = partial_ordering>
    concept three_way_comparable_with =
      __WeaklyEqualityComparableWith<T, U> &&
      __PartiallyOrderedWith<T, U> &&
      three_way_comparable<T, Cat> &&
      three_way_comparable<U, Cat> &&
      common_reference_with<const remove_reference_t<T>&, const remove_reference_t<U>&> &&
      three_way_comparable<
        common_reference_t<
          const remove_reference_t<T>&, const remove_reference_t<U>&>, Cat> &&
      requires(const remove_reference_t<T>& t, const remove_reference_t<U>& u) {
        { t <=> u } -> __ComparesAs<Cat>;
        { u <=> t } -> __ComparesAs<Cat>;
      };
}

Класс std::partial_ordering

namespace std {
  class partial_ordering {
    int value;          // только экспозиция
    bool is_ordered;    // только экспозиция

    // конструкторы только для экспозиции
    constexpr explicit
      partial_ordering(eq v) noexcept :
        value(int(v)), is_ordered(true) {}      // только экспозиция
    constexpr explicit
      partial_ordering(ord v) noexcept :
        value(int(v)), is_ordered(true) {}     // только экспозиция
      partial_ordering(ncmp v) noexcept :
        value(int(v)), is_ordered(false) {}   // только экспозиция

  public:
    // действительные значения
    static const partial_ordering less;
    static const partial_ordering equivalent;
    static const partial_ordering greater;
    static const partial_ordering unordered;

    // сравнения
    friend constexpr bool operator==(partial_ordering v, /* не определено */) noexcept;
    friend constexpr bool
      operator==(partial_ordering v, partial_ordering w) noexcept = default;
    friend constexpr bool operator< (partial_ordering v, /* не определено */) noexcept;
    friend constexpr bool operator> (partial_ordering v, /* не определено */) noexcept;
    friend constexpr bool operator<=(partial_ordering v, /* не определено */) noexcept;
    friend constexpr bool operator>=(partial_ordering v, /* не определено */) noexcept;
    friend constexpr bool operator< (/* не определено */, partial_ordering v) noexcept;
    friend constexpr bool operator> (/* не определено */, partial_ordering v) noexcept;
    friend constexpr bool operator<=(/* не определено */, partial_ordering v) noexcept;
    friend constexpr bool operator>=(/* не определено */, partial_ordering v) noexcept;
    friend constexpr partial_ordering
      operator<=>(partial_ordering v, /* не определено */) noexcept;
    friend constexpr partial_ordering
      operator<=>(/* не определено */, partial_ordering v) noexcept;
  };

  // определения допустимых значений
  inline constexpr partial_ordering partial_ordering::less(ord::less);
  inline constexpr partial_ordering partial_ordering::equivalent(eq::equivalent);
  inline constexpr partial_ordering partial_ordering::greater(ord::greater);
  inline constexpr partial_ordering partial_ordering::unordered(ncmp::unordered);
}

Класс std::weak_ordering

namespace std {
  class weak_ordering {
    int value;  // только экспозиция

    // конструкторы только для экспозиции
    constexpr explicit weak_ordering(eq v) noexcept : value(int(v)) {} 
        // только экспозиция
    constexpr explicit weak_ordering(ord v) noexcept : value(int(v)) {}
        // только экспозиция

  public:
    // действительные значения
    static const weak_ordering less;
    static const weak_ordering equivalent;
    static const weak_ordering greater;

    // преобразования
    constexpr operator partial_ordering() const noexcept;

    // сравнения
    friend constexpr bool operator==(weak_ordering v, /* не определено */) noexcept;
    friend constexpr bool operator==(weak_ordering v, weak_ordering w) noexcept = default;
    friend constexpr bool operator< (weak_ordering v, /* не определено */) noexcept;
    friend constexpr bool operator> (weak_ordering v, /* не определено */) noexcept;
    friend constexpr bool operator<=(weak_ordering v, /* не определено */) noexcept;
    friend constexpr bool operator>=(weak_ordering v, /* не определено */) noexcept;
    friend constexpr bool operator< (/* не определено */, weak_ordering v) noexcept;
    friend constexpr bool operator> (/* не определено */, weak_ordering v) noexcept;
    friend constexpr bool operator<=(/* не определено */, weak_ordering v) noexcept;
    friend constexpr bool operator>=(/* не определено */, weak_ordering v) noexcept;
    friend constexpr weak_ordering
      operator<=>(weak_ordering v, /* не определено */) noexcept;
    friend constexpr weak_ordering
      operator<=>(/* не определено */, weak_ordering v) noexcept;
  };

  // определения допустимых значений
  inline constexpr weak_ordering weak_ordering::less(ord::less);
  inline constexpr weak_ordering weak_ordering::equivalent(eq::equivalent);
  inline constexpr weak_ordering weak_ordering::greater(ord::greater);
}

Класс std::strong_ordering

namespace std {
  class strong_ordering {
    int value;  // только экспозиция

    // конструкторы только для экспозиции
    constexpr explicit strong_ordering(eq v) noexcept :
      value(int(v)) {}    // только экспозиция
    constexpr explicit strong_ordering(ord v) noexcept :
      value(int(v)) {}   // только экспозиция

  public:
    // действительные значения
    static const strong_ordering less;
    static const strong_ordering equal;
    static const strong_ordering equivalent;
    static const strong_ordering greater;

    // преобразования
    constexpr operator partial_ordering() const noexcept;
    constexpr operator weak_ordering() const noexcept;

    // сравнения
    friend constexpr bool operator==(strong_ordering v, /* не определено */) noexcept;
    friend constexpr bool
      operator==(strong_ordering v, strong_ordering w) noexcept = default;
    friend constexpr bool operator< (strong_ordering v, /* не определено */) noexcept;
    friend constexpr bool operator> (strong_ordering v, /* не определено */) noexcept;
    friend constexpr bool operator<=(strong_ordering v, /* не определено */) noexcept;
    friend constexpr bool operator>=(strong_ordering v, /* не определено */) noexcept;
    friend constexpr bool operator< (/* не определено */, strong_ordering v) noexcept;
    friend constexpr bool operator> (/* не определено */, strong_ordering v) noexcept;
    friend constexpr bool operator<=(/* не определено */, strong_ordering v) noexcept;
    friend constexpr bool operator>=(/* не определено */, strong_ordering v) noexcept;
    friend constexpr strong_ordering
      operator<=>(strong_ordering v, /* не определено */) noexcept;
    friend constexpr strong_ordering
    operator<=>(/* не определено */, strong_ordering v) noexcept;
  };

  // определения допустимых значений
  inline constexpr strong_ordering strong_ordering::less(ord::less);
  inline constexpr strong_ordering strong_ordering::equal(eq::equal);
  inline constexpr strong_ordering strong_ordering::equivalent(eq::equivalent);
  inline constexpr strong_ordering strong_ordering::greater(ord::greater);
}

Класс std::compare_three_way

namespace std {
  struct compare_three_way {
    template<class T, class U>
    constexpr auto operator()(T&& t, U&& u) const;

    using is_transparent = /* не определено */;
  };
}

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

выражение оператора трёхстороннего сравнения lhs <=> rhs (C++20)