Стандартная библиотека заголовок <compare> (C++20)
Этот заголовок является частью библиотеки поддержки языка.
Концепции |
|
|
(C++20) | определяет, что оператор <=> производит согласованный результат для заданных типов (концепция) |
Классы |
|
|
(C++20) | тип результата 3-х стороннего сравнения, поддерживающий все 6 операторов, не является замещаемым и допускает несравнимые значения (класс) |
|
(C++20) | тип результата 3-х стороннего сравнения, поддерживающий все 6 операторов и не является замещаемым (класс) |
|
(C++20) | тип результата 3-х стороннего сравнения, поддерживающий все 6 операторов и замещаемый (класс) |
|
(C++20) | самая сильная категория сравнения, в которую все заданные типы могут быть преобразованы (шаблон класса) |
|
(C++20) | получает тип результата оператора трехстороннего сравнения <=> для заданных типов (шаблон класса) |
|
(C++20) | объект-функция, реализующий x <=> y (класс) |
Объекты точек кастомизации |
|
|
(C++20) | выполняет трехстороннее сравнение и производит результат типа std::strong_ordering(объект точки кастомизации) |
|
(C++20) | выполняет трехстороннее сравнение и производит результат типа std::weak_ordering(объект точки кастомизации) |
|
(C++20) | выполняет трехстороннее сравнение и производит результат типа std::partial_ordering(объект точки кастомизации) |
|
(C++20) | выполняет трехстороннее сравнение и производит результат типа std::strong_ordering, даже если operator<=> недоступен(объект точки кастомизации) |
|
(C++20) | выполняет трехстороннее сравнение и производит результат типа std::weak_ordering, даже если operator<=> недоступен(объект точки кастомизации) |
|
(C++20) | выполняет трехстороннее сравнение и производит результат типа std::partial_ordering, даже если operator<=> недоступен(объект точки кастомизации) |
Функции |
|
|
(C++20) | именованные функции сравнения (функция) |
Сводка
namespace std {
// comparison category types
class partial_ordering;
class weak_ordering;
class strong_ordering;
// named comparison functions
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; }
// common comparison category type
template<class... Ts>
struct common_comparison_category {
using type = /* see description */;
};
template<class... Ts>
using common_comparison_category_t = typename common_comparison_category<Ts...>::type;
// concept three_way_comparable
template<class T, class Cat = partial_ordering>
concept three_way_comparable = /* see description */;
template<class T, class U, class Cat = partial_ordering>
concept three_way_comparable_with = /* see description */;
// result of three-way comparison
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;
// class compare_three_way
struct compare_three_way;
// comparison algorithms
inline namespace /* unspecified */ {
inline constexpr /* unspecified */ strong_order = /* unspecified */;
inline constexpr /* unspecified */ weak_order = /* unspecified */;
inline constexpr /* unspecified */ partial_order = /* unspecified */;
inline constexpr /* unspecified */ compare_strong_order_fallback = /* unspecified */;
inline constexpr /* unspecified */ compare_weak_order_fallback = /* unspecified */;
inline constexpr /* unspecified */ compare_partial_order_fallback = /* unspecified */;
}
} Концепция three_way_comparable
namespace std {
template<class T, class Cat>
concept __ComparesAs = // exposition only
same_as<common_comparison_category_t<T, Cat>, Cat>;
template<class T, class U>
concept __PartiallyOrderedWith = // exposition only
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; // exposition only
bool is_ordered; // exposition only
// exposition-only constructors
constexpr explicit
partial_ordering(eq v) noexcept :
value(int(v)), is_ordered(true) {} // exposition only
constexpr explicit
partial_ordering(ord v) noexcept :
value(int(v)), is_ordered(true) {} // exposition only
constexpr explicit
partial_ordering(ncmp v) noexcept :
value(int(v)), is_ordered(false) {} // exposition only
public:
// valid values
static const partial_ordering less;
static const partial_ordering equivalent;
static const partial_ordering greater;
static const partial_ordering unordered;
// comparisons
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;
};
// valid values' definitions
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; // exposition only
// exposition-only constructors
constexpr explicit weak_ordering(eq v) noexcept : value(int(v)) {} // exposition only
constexpr explicit weak_ordering(ord v) noexcept : value(int(v)) {} // exposition only
public:
// valid values
static const weak_ordering less;
static const weak_ordering equivalent;
static const weak_ordering greater;
// conversions
constexpr operator partial_ordering() const noexcept;
// comparisons
friend constexpr bool operator==(weak_ordering v, /* unspecified */) noexcept;
friend constexpr bool operator==(weak_ordering v, weak_ordering w) noexcept = default;
friend constexpr bool operator< (weak_ordering v, /* unspecified */) noexcept;
friend constexpr bool operator> (weak_ordering v, /* unspecified */) noexcept;
friend constexpr bool operator<=(weak_ordering v, /* unspecified */) noexcept;
friend constexpr bool operator>=(weak_ordering v, /* unspecified */) noexcept;
friend constexpr bool operator< (/* unspecified */, weak_ordering v) noexcept;
friend constexpr bool operator> (/* unspecified */, weak_ordering v) noexcept;
friend constexpr bool operator<=(/* unspecified */, weak_ordering v) noexcept;
friend constexpr bool operator>=(/* unspecified */, weak_ordering v) noexcept;
friend constexpr weak_ordering
operator<=>(weak_ordering v, /* unspecified */) noexcept;
friend constexpr weak_ordering
operator<=>(/* unspecified */, weak_ordering v) noexcept;
};
// valid values' definitions
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; // exposition only
// exposition-only constructors
constexpr explicit strong_ordering(eq v) noexcept :
value(int(v)) {} // exposition only
constexpr explicit strong_ordering(ord v) noexcept :
value(int(v)) {} // exposition only
public:
// valid values
static const strong_ordering less;
static const strong_ordering equal;
static const strong_ordering equivalent;
static const strong_ordering greater;
// conversions
constexpr operator partial_ordering() const noexcept;
constexpr operator weak_ordering() const noexcept;
// comparisons
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;
};
// valid values' definitions
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) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/header/compare
