operator==,!=,<,<=,>,>=,<=>(std::tuple)

 

C++

编译器支持

独立和托管

语言

标准库

标准库头文件

命名要求

功能测试宏 (C++20)

语言支持库

概念库 (C++20)

元编程库 (C++11)

诊断库

通用实用程序库

字符串库

容器库

迭代器库

范围库 (C++20)

算法库

数值库

本地化库

输入/输出库

文件系统库 (C++17)

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

并发支持库 (C++11)

执行支持库 (C++26)

技术规范

符号索引

外部库

 

实用程序库

语言支持 类型支持 (基本类型，RTTI) 库功能测试宏 (C++20) 动态内存管理 程序实用程序 协程支持 (C++20) 可变参数函数 is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) 调试支持 is_debugger_present (C++26) breakpoint_if_debugging (C++26) breakpoint (C++26) 三向比较 three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)    is_eqis_ltis_lteq (C++20)(C++20)(C++20) is_neqis_gtis_gteq (C++20)(C++20)(C++20)

通用实用程序 日期和时间 函数对象 格式化库 (C++20) bitset hash (C++11) 关系运算符 (在 C++20 中已弃用) rel_ops::operator!=rel_ops::operator>     rel_ops::operator<=rel_ops::operator>= 整数比较函数 cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)    cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) 交换 和 类型操作 swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) 通用词汇类型 pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23) 基本字符串转换 to_chars (C++17) from_chars (C++17) chars_format (C++17) to_chars_result (C++17) from_chars_result (C++17)

 

std::tuple

成员函数

tuple::tuple

tuple::operator=

tuple::swap

非成员函数

make_tuple

tie

forward_as_tuple

tuple_cat

operator==operator!=operator<operator<=operator>operator>=operator<=> (直到 C++20)(直到 C++20)(直到 C++20)(直到 C++20)(直到 C++20)(C++20)

swap(std::tuple)

get(std::tuple)

辅助概念

tuple-like (C++23)

辅助类

tuple_size<std::tuple>

tuple_element<std::tuple>

uses_allocator<std::tuple>

basic_common_reference<std::tuple> (C++23)

common_type<std::tuple> (C++23)

formatter<std::tuple> (C++23)

ignore

推导指南(C++17)

 

定义在头文件 <tuple> 中
template< class... TTypes, class... UTypes > bool operator==( const std::tuple<TTypes...>& lhs,                  const std::tuple<UTypes...>& rhs );	(1)	(自 C++11 起) (自 C++14 起为 constexpr)
template< class... TTypes, class... UTypes > bool operator!=( const std::tuple<TTypes...>& lhs,                  const std::tuple<UTypes...>& rhs );	(2)	(自 C++11 起) (自 C++14 起为 constexpr) (直到 C++20)
template< class... TTypes, class... UTypes > bool operator<( const std::tuple<TTypes...>& lhs,                 const std::tuple<UTypes...>& rhs );	(3)	(自 C++11 起) (自 C++14 起为 constexpr) (直到 C++20)
template< class... TTypes, class... UTypes > bool operator<=( const std::tuple<TTypes...>& lhs,                  const std::tuple<UTypes...>& rhs );	(4)	(自 C++11 起) (自 C++14 起为 constexpr) (直到 C++20)
template< class... TTypes, class... UTypes > bool operator>( const std::tuple<TTypes...>& lhs,                 const std::tuple<UTypes...>& rhs );	(5)	(自 C++11 起) (自 C++14 起为 constexpr) (直到 C++20)
template< class... TTypes, class... UTypes > bool operator>=( const std::tuple<TTypes...>& lhs,                  const std::tuple<UTypes...>& rhs );	(6)	(自 C++11 起) (自 C++14 起为 constexpr) (直到 C++20)
template< class... TTypes, class... UTypes > constexpr std::common_comparison_category_t<     synth-three-way-result<TTypes, Elems>...>     operator<=>( const std::tuple<TTypes...>& lhs,                  const std::tuple<UTypes...>& rhs );	(7)	(自 C++20 起)
template< class... TTypes, tuple-like UTuple > constexpr bool operator==( const tuple<TTypes...>& lhs, const UTuple& rhs );	(8)	(自 C++23 起)
template< class... TTypes, tuple-like UTuple > constexpr std::common_comparison_category_t<     synth-three-way-result<TTypes, /* Elems */>...>     operator<=>( const tuple<TTypes...>& lhs, const UTuple& rhs );	(9)	(自 C++23 起)

1,2) 使用 operator== 比较元组 lhs 的每个元素与元组 rhs 的对应元素。

1) 如果所有对应元素对相等，则返回 true。

2) 返回 !(lhs == rhs)。

如果 sizeof...(TTypes) 不等于 sizeof...(UTypes)，或者对于任何在 [​0​, sizeof...(Types)) 范围内的 i，std::get<i>(lhs) == std::get<i>(rhs) 不是有效的表达式，程序将形成错误。 如果对于任何在 [​0​, sizeof...(Types)) 范围内的 i，std::get<i>(lhs) == std::get<i>(rhs) 的类型和值类别不满足 BooleanTestable 要求，则行为未定义。	(直到 C++26)
只有当 sizeof...(TTypes) 等于 sizeof...(UTypes)、std::get<i>(lhs) == std::get<i>(rhs) 是一个有效的表达式，并且对于每个在 [​0​, sizeof...(Types)) 范围内的 i，decltype(std::get<i>(lhs) == std::get<i>(rhs)) 符合 boolean-testable 时，此重载才会参与重载解析。	(自 C++26 起)

3-6) 使用 operator< 按字典顺序比较 lhs 和 rhs，即比较第一个元素，如果它们等效，则比较第二个元素，如果它们等效，则比较第三个元素，依此类推。

3) 对于空元组，返回 false。对于非空元组，其效果等效于
if (std::get<0>(lhs) < std::get<0>(rhs)) return true;

if (std::get<0>(rhs) < std::get<0>(lhs)) return false;
if (std::get<1>(lhs) < std::get<1>(rhs)) return true;
if (std::get<1>(rhs) < std::get<1>(lhs)) return false;
...

return std::get<N - 1>(lhs) < std::get<N - 1>(rhs);

4) 返回 !(rhs < lhs)。

5) 返回 rhs < lhs。

6) 返回 !(lhs < rhs)。

如果 sizeof...(TTypes) 不等于 sizeof...(UTypes)，或者等效于语句中显示的任何比较表达式不是有效表达式，程序将形成错误。

如果等效于语句中显示的任何比较表达式的类型和值类别不满足 BooleanTestable 要求，则行为未定义。

7) 使用 synth-three-way 按字典顺序比较 lhs 和 rhs，即比较第一个元素，如果它们等效，则比较第二个元素，如果它们等效，则比较第三个元素，依此类推。

• 对于空元组，返回 std::strong_ordering::equal。
• 对于非空元组，其效果等效于

if (auto c = synth-three-way(std::get<0>(lhs), std::get<0>(rhs)); c != 0) return c;
if (auto c = synth-three-way(std::get<1>(lhs), std::get<1>(rhs)); c != 0) return c;
...
return synth-three-way(std::get<N - 1>(lhs), std::get<N - 1>(rhs));

8) 与 (1) 相同，除了 rhs 是一个 tuple-like 对象，并且 rhs 的元素数量由 std::tuple_size_v<UTuple> 确定。此重载只能通过 依赖于参数的查找 找到。

9) 与 (7) 相同，除了 rhs 是一个 tuple-like 对象。 /* Elems */ 表示类型包 std::tuple_element_t<i, UTuple>，对于每个在 [​0​, std::tuple_size_v<UTuple>) 范围内的 i，按升序排列。此重载只能通过 依赖于参数的查找 找到。

所有比较运算符都是短路运算符；它们不会访问超出确定比较结果所需的元组元素。

<、<=、>、>= 和 != 运算符分别由 operator<=> 和 operator== 合成。

(自 C++20 起)

参数

lhs, rhs

-

要比较的元组

返回值

1,8) true 如果 std::get<i>(lhs) == std::get<i>(rhs) 对于所有 i 在 [​0​, sizeof...(Types)) 中，否则 false。对于两个空元组，返回 true。

2) !(lhs == rhs)

3) true 如果 lhs 中的第一个非等价元素小于 rhs 中的元素，false 如果 rhs 中的第一个非等价元素小于 lhs 中的元素，或者不存在非等价元素。对于两个空元组，返回 false。

4) !(rhs < lhs)

5) rhs < lhs

6) !(lhs < rhs)

7,9) 如果存在，则返回第一对非等价元素之间的关系，否则返回 std::strong_ordering::equal。对于两个空元组，返回 std::strong_ordering::equal。

注释

关系运算符是根据每个元素的 operator< 定义的。	(直到 C++20)
关系运算符是根据 synth-three-way 定义的，如果可能，它使用 operator<=>，否则使用 operator<。 值得注意的是，如果元素类型本身不提供 operator<=>，但可以隐式转换为三向可比较类型，则将使用该转换而不是 operator<。	(自 C++20 起)

特性测试 宏	值	Std	特性
__cpp_lib_constrained_equality	202403L	(C++26)	受限 operator== 用于 std::tuple

示例

由于为元组定义了 operator<，因此可以对元组容器进行排序。

运行此代码

#include <algorithm>
#include <iostream>
#include <tuple>
#include <vector>
 
int main()
{
    std::vector<std::tuple<int, std::string, float>> v
    {
        {2, "baz", -0.1},
        {2, "bar", 3.14},
        {1, "foo", 10.1},
        {2, "baz", -1.1},
    };
    std::sort(v.begin(), v.end());
 
    for (const auto& p: v)
        std::cout << "{ " << get<0>(p)
                  << ", " << get<1>(p)
                  << ", " << get<2>(p)
                  << " }\n";
}

输出

{ 1, foo, 10.1 }
{ 2, bar, 3.14 }
{ 2, baz, -1.1 }
{ 2, baz, -0.1 }

缺陷报告

以下行为更改缺陷报告被追溯应用于先前发布的 C++ 标准。

DR	应用于	发布的行为	正确的行为
LWG 2114 (P2167R3)	C++11	布尔运算的类型先决条件丢失	已添加

另请参阅

operator==operator!=operator<operator<=operator>operator>=operator<=> (在 C++20 中移除)(在 C++20 中移除)(在 C++20 中移除)(在 C++20 中移除)(在 C++20 中移除)(C++20)

按字典顺序比较 pair 中的值 (函数模板)