标准库头文件 <compare>

 

C++

语言

标准库头文件

自立与有宿主实现

具名要求

语言支持库

概念库 (C++20)

诊断库

工具库

字符串库

容器库

迭代器库

范围库 (C++20)

算法库

数值库

本地化库

输入/输出库

文件系统库 (C++17)

正则表达式库 (C++11)

原子操作库 (C++11)

线程支持库 (C++11)

技术规范

 

标准库头文件

语言支持
<cstddef> <cstdlib> <version> <limits> <climits>	<cfloat> <cstdint> <new> <typeinfo>	<source_location> <exception> <initializer_list>     <compare>	<coroutine> <csignal> <csetjmp> <cstdarg>
概念
<concepts>
诊断
<stdexcept>	<cassert>	<cerrno>	<system_error>
通用工具
<utility> <memory> <memory_resource> <scoped_allocator>	<bitset> <tuple> <optional> <any>	<variant> <type_traits> <ratio> <chrono>	<typeindex> <functional> <stacktrace> <ctime>
字符串
<string> <string_view> <cstring>	<charconv> <format>	<cctype> <cwctype>	<cwchar> <cuchar>
本地化
<locale>	<codecvt>	<clocale>
容器
<span> <array> <vector>	<deque> <forward_list> <list>	<map> <set> <queue>	<unordered_map> <unordered_set> <stack>
迭代器
<iterator>
范围
<ranges>
算法
<algorithm>	<execution>
数值
<complex> <random>	<valarray> <numeric>	<bit> <numbers>	<cfenv> <cmath>
输入/输出
<iosfwd> <ios> <iomanip> <streambuf>	<istream> <ostream> <iostream>	<sstream> <spanstream> <fstream> <syncstream>	<cstdio> <cinttypes> <strstream>
正则表达式
<regex>
文件系统
<filesystem>
线程支持
<thread> <atomic> <mutex>	<shared_mutex> <condition_variable>     <future>	<stop_token> <semaphore>	<latch> <barrier>
C 兼容
<ciso646> <cstdalign>	<cstdbool> <ccomplex>	<ctgmath> <stdatomic.h>

 

此头文件是语言支持库的一部分。

概念
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) {}     // 仅用于阐释
    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, /* 未指明 */) 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 = /* 未指明 */;
  };
}