Standard library header <compare> (C++20)

From cppreference.net

< cpp ‎ | header

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

Содержание

Концепции

three_way_comparable three_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_eq is_neq is_lt is_lteq is_gt is_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) {}     // только для демонстрации
    constexpr explicit
      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, /* unspecified */) noexcept;
    friend constexpr bool
      operator==(partial_ordering v, partial_ordering w) noexcept = default;
    friend constexpr bool operator< (partial_ordering v, /* unspecified */) noexcept;
    friend constexpr bool operator> (partial_ordering v, /* unspecified */) noexcept;
    friend constexpr bool operator<=(partial_ordering v, /* unspecified */) noexcept;
    friend constexpr bool operator>=(partial_ordering v, /* unspecified */) noexcept;
    friend constexpr bool operator< (/* unspecified */, partial_ordering v) noexcept;
    friend constexpr bool operator> (/* unspecified */, partial_ordering v) noexcept;
    friend constexpr bool operator<=(/* unspecified */, partial_ordering v) noexcept;
    friend constexpr bool operator>=(/* unspecified */, partial_ordering v) noexcept;
    friend constexpr partial_ordering
      operator<=>(partial_ordering v, /* unspecified */) noexcept;
    friend constexpr partial_ordering
      operator<=>(/* unspecified */, 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, /* unspecified */) noexcept;
    friend constexpr bool
      operator==(strong_ordering v, strong_ordering w) noexcept = default;
    friend constexpr bool operator< (strong_ordering v, /* unspecified */) noexcept;
    friend constexpr bool operator> (strong_ordering v, /* unspecified */) noexcept;
    friend constexpr bool operator<=(strong_ordering v, /* unspecified */) noexcept;
    friend constexpr bool operator>=(strong_ordering v, /* unspecified */) noexcept;
    friend constexpr bool operator< (/* unspecified */, strong_ordering v) noexcept;
    friend constexpr bool operator> (/* unspecified */, strong_ordering v) noexcept;
    friend constexpr bool operator<=(/* unspecified */, strong_ordering v) noexcept;
    friend constexpr bool operator>=(/* unspecified */, strong_ordering v) noexcept;
    friend constexpr strong_ordering
      operator<=>(strong_ordering v, /* unspecified */) noexcept;
    friend constexpr strong_ordering
    operator<=>(/* unspecified */, 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 = /* unspecified */;
  };
}

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

оператор трёхстороннего сравнения выражение lhs

<=>

rhs (C++20)

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants

Standard library header <compare> (C++20)

Содержание

Концепции

Классы

Объекты точек кастомизации

Функции

Синопсис

Концепт `three_way_comparable`

Концепт `three_way_comparable_with`

Класс std:: partial_ordering

Класс std:: weak_ordering

Класс std:: strong_ordering

Класс std:: compare_three_way

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

cppreference.net

Namespaces

Variants

Standard library header <compare> (C++20)

Содержание

Концепции

Классы

Объекты точек кастомизации

Функции

Синопсис

Концепт three_way_comparable

Концепт three_way_comparable_with

Класс std:: partial_ordering

Класс std:: weak_ordering

Класс std:: strong_ordering

Класс std:: compare_three_way

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

Концепт `three_way_comparable`

Концепт `three_way_comparable_with`