C++ 参考手册
- C++11
- C++14
- C++17
- C++20
- C++ 编译器支持情况表
- 独立与宿主实现
- C++ 语言
- C++ 关键词
- 预处理器
- C++ 标准库头文件
- 标准库头文件 <ctime>
- 标准库头文件 <cstring>
- 标准库头文件 <set>
- 标准库头文件 <cctype>
- 标准库头文件 <cwctype>
- 标准库头文件 <utility>
- 标准库头文件 <queue>
- 标准库头文件 <complex>
- 标准库头文件 <iterator>
- 标准库头文件 <algorithm>
- 标准库头文件 <valarray>
- 标准库头文件 <numeric>
- 标准库头文件 <cmath>
- 标准库头文件 <iosfwd>
- 标准库头文件 <ios>
- 标准库头文件 <iomanip>
- 标准库头文件 <streambuf>
- 标准库头文件 <istream>
- 标准库头文件 <ostream>
- 标准库头文件 <iostream>
- 标准库头文件 <sstream>
- 标准库头文件 <clocale>
- 标准库头文件 <vector>
- 标准库头文件 <deque>
- 标准库头文件 <list>
- 标准库头文件 <map>
- 标准库头文件 <cwchar>
- 标准库头文件 <locale>
- 标准库头文件 <codecvt>
- 标准库头文件 <bitset>
- 标准库头文件 <functional>
- 标准库头文件 <stdexcept>
- 标准库头文件 <csignal>
- 标准库头文件 <csetjmp>
- 标准库头文件 <stack>
- 标准库头文件 <cassert>
- 标准库头文件 <cerrno>
- 标准库头文件 <memory>
- 标准库头文件 <typeindex>
- 标准库头文件 <type_traits>
- 标准库头文件 <chrono>
- 标准库头文件 <initializer_list>
- 标准库头文件 <tuple>
- 标准库头文件 <scoped_allocator>
- 标准库头文件 <cstdint>
- 标准库头文件 <cinttypes>
- 标准库头文件 <system_error>
- 标准库头文件 <cuchar>
- 标准库头文件 <array>
- 标准库头文件 <forward_list>
- 标准库头文件 <unordered_set>
- 标准库头文件 <unordered_map>
- 标准库头文件 <random>
- 标准库头文件 <ratio>
- 标准库头文件 <cfenv>
- 标准库头文件 <regex>
- 标准库头文件 <atomic>
- 标准库头文件 <thread>
- 标准库头文件 <mutex>
- 标准库头文件 <future>
- 标准库头文件 <condition_variable>
- 标准库头文件 <any>
- 标准库头文件 <optional>
- 标准库头文件 <variant>
- 标准库头文件 <memory_resource>
- 标准库头文件 <string_view>
- 标准库头文件 <charconv>
- 标准库头文件 <execution>
- 标准库头文件 <filesystem>
- 标准库头文件 <concepts>
- 标准库头文件 <coroutine>
- 标准库头文件 <compare>
- 标准库头文件 <version>
- 标准库头文件 <source_location>
- 标准库头文件 <format>
- 标准库头文件 <span>
- 标准库头文件 <ranges>
- 标准库头文件 <bit>
- 标准库头文件 <numbers>
- 标准库头文件 <syncstream>
- 标准库头文件 <stop_token>
- 标准库头文件 <semaphore>
- 标准库头文件 <latch>
- 标准库头文件 <barrier>
- 标准库头文件 <string>
- 标准库头文件 <cstddef>
- 标准库头文件 <limits>
- 标准库头文件 <cfloat>
- 标准库头文件 <climits>
- 标准库头文件 <cstdlib>
- 标准库头文件 <new>
- 标准库头文件 <typeinfo>
- 标准库头文件 <exception>
- 标准库头文件 <cstdarg>
- 标准库头文件 <ciso646>
- 标准库头文件 <cstdalign>
- 标准库头文件 <cstdbool>
- 标准库头文件 <fstream>
- 标准库头文件 <cstdio>
- 标准库头文件 <strstream>
- 标准库头文件 <shared_mutex>
- 标准库头文件 <ccomplex>
- 标准库头文件 <ctgmath>
- 注释
- 具名要求
- 功能特性测试 (C++20)
- 工具库
- 类型支持（基本类型、RTTI、类型特性）
- 概念库 (C++20)
- 错误处理
- 动态内存管理
- 日期和时间工具
- 字符串库
- 容器库
- 迭代器库
- 范围库 (C++20)
- 算法库
- 数值库
- 输入/输出库
- 文件系统库
- 本地化库
- 正则表达式库
- 原子操作库
- 线程支持库
- 实验性 C++ 特性
- 有用的资源
- 索引
- std 符号索引
- 协程支持 (C++20)
- C++ 关键词
位置：首页 > C++ 参考手册 >C++ 标准库头文件 > 标准库头文件 <compare>
标准库头文件 <compare>
此头文件是通用工具库的一部分。
概念
| 指定运算符 <=> 在给定类型上产生一致的结果 (概念) |
类
| (C++20) |
三路比较的结果类型，支持所有 6 种运算符，不可替换，并允许不可比较的值 (类) |
| (C++20) |
三路比较的结果类型，支持所有 6 种运算符且不可替换 (类) |
| (C++20) |
三路比较的结果类型，支持所有 6 种运算符且可替换 (类) |
| (C++20) |
给定的全部类型都能转换到的最强比较类别 (类模板) |
| (C++20) |
获得三路比较运算符 <=> 在给定类型上的结果 (类模板) |
| (C++20) |
实现 x <=> y 的函数对象 (类) |
定制点对象
| (C++20) |
进行三路比较并产生 std::strong_ordering 类型结果 (定制点对象) |
| (C++20) |
进行三路比较并产生 std::weak_ordering 类型结果 (定制点对象) |
| (C++20) |
进行三路比较并产生 std::partial_ordering 类型结果 (定制点对象) |
进行三路比较并产生 std::strong_ordering 类型的结果，即使 operator<=> 不可用 (定制点对象) | |
| (C++20) |
进行三路比较并产生 std::weak_ordering 类型的结果，即使 operator<=> 不可用 (定制点对象) |
进行三路比较并产生 std::partial_ordering 类型的结果，即使 operator<=> 不可用 (定制点对象) |
函数
| 具名比较函数 (函数) |
概要
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 = /* see description */; }; 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 = /* see description */; template<class T, class U, class Cat = partial_ordering> concept three_way_comparable_with = /* see description */; // 三路比较的结果 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; { t > u } -> boolean; { t <= u } -> boolean; { t >= u } -> boolean; { u < t } -> boolean; { u > t } -> boolean; { u <= t } -> boolean; { u >= t } -> boolean; }; 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> requires three_way_comparable_with<T, U> || /*BUILTIN-PTR-THREE-WAY*/(T, U) constexpr auto operator()(T&& t, U&& u) const; using is_transparent = /* 未指明 */; }; }