operator==,!=,<,<=,>,>=,<=>(std::tuple)
Defined in header <tuple>
|
||
template< class... TTypes, class... UTypes > bool operator==( const std::tuple<TTypes...>& lhs, |
(1) | (since C++11) (constexpr since C++14) |
template< class... TTypes, class... UTypes > bool operator!=( const std::tuple<TTypes...>& lhs, |
(2) | (since C++11) (constexpr since C++14) (until C++20) |
template< class... TTypes, class... UTypes > bool operator<( const std::tuple<TTypes...>& lhs, |
(3) | (since C++11) (constexpr since C++14) (until C++20) |
template< class... TTypes, class... UTypes > bool operator<=( const std::tuple<TTypes...>& lhs, |
(4) | (since C++11) (constexpr since C++14) (until C++20) |
template< class... TTypes, class... UTypes > bool operator>( const std::tuple<TTypes...>& lhs, |
(5) | (since C++11) (constexpr since C++14) (until C++20) |
template< class... TTypes, class... UTypes > bool operator>=( const std::tuple<TTypes...>& lhs, |
(6) | (since C++11) (constexpr since C++14) (until C++20) |
template< class... TTypes, class... UTypes > constexpr std::common_comparison_category_t< |
(7) | (since C++20) |
template< class... TTypes, tuple-like UTuple > constexpr bool operator==( const tuple<TTypes...>& lhs, const UTuple& rhs ); |
(8) | (since C++23) |
template< class... TTypes, tuple-like UTuple > constexpr std::common_comparison_category_t< |
(9) | (since C++23) |
If sizeof...(TTypes) does not equal sizeof...(UTypes), or std::get<i>(lhs) == std::get<i>(rhs) is not a valid expression for any i in
[ 0, sizeof...(Types)) , the program is ill-formed. If the type and value category of std::get<i>(lhs) == std::get<i>(rhs) do not meet the BooleanTestable requirements for any i in [ 0, sizeof...(Types)) , the behavior is undefined.
|
(until C++26) |
This overload participates in overload resolution only if sizeof...(TTypes) equals sizeof...(UTypes), std::get<i>(lhs) == std::get<i>(rhs) is a valid expression and decltype(std::get<i>(lhs) == std::get<i>(rhs)) model boolean-testable for every i in [ 0, sizeof...(Types)) .
|
(since C++26) |
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;
...
- For empty tuples, returns std::strong_ordering::equal.
- For non-empty tuples, the effect is equivalent to
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));
tuple-like
object, and the number of elements of rhs is determined by std::tuple_size_v<UTuple> instead. This overload can only be found via argument-dependent lookup.tuple-like
object. /* Elems */ denotes the pack of types std::tuple_element_t<i, UTuple> for each i in [
0,
std::tuple_size_v<UTuple>)
in increasing order. This overload can only be found via argument-dependent lookup.All comparison operators are short-circuited; they do not access tuple elements beyond what is necessary to determine the result of the comparison.
The |
(since C++20) |
Contents |
[edit] Parameters
lhs, rhs | - | tuples to compare |
[edit] Return value
[
0,
sizeof...(Types))
, otherwise false. For two empty tuples returns true.[edit] Notes
The relational operators are defined in terms of each element's operator<. |
(until C++20) |
The relational operators are defined in terms of synth-three-way, which uses operator<=> if possible, or operator< otherwise. Notably, if an element type does not itself provide operator<=>, but is implicitly convertible to a three-way comparable type, that conversion will be used instead of operator<. |
(since C++20) |
Feature-test macro | Value | Std | Feature |
---|---|---|---|
__cpp_lib_constrained_equality |
202403L | (C++26) | Constrained operator== for std::tuple |
[edit] Example
Because operator< is defined for tuples, containers of tuples can be sorted.
#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"; }
Output:
{ 1, foo, 10.1 } { 2, bar, 3.14 } { 2, baz, -1.1 } { 2, baz, -0.1 }
[edit] Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
DR | Applied to | Behavior as published | Correct behavior |
---|---|---|---|
LWG 2114 (P2167R3) |
C++11 | type preconditions for boolean operations were missing | added |
[edit] See also
(removed in C++20)(removed in C++20)(removed in C++20)(removed in C++20)(removed in C++20)(C++20) |
lexicographically compares the values in the pair (function template) |