3) For empty tuples, returns false. For non-empty tuples, the effect is equivalent to
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) Returns !(rhs < lhs).

5) Returns rhs < lhs.

6) Returns !(lhs < rhs).

If sizeof...(TTypes) does not equal sizeof...(UTypes), or any of the comparison expression shown in the equivalent-to statements is not a valid expression, the program is ill-formed.

If the type and value category of any of the comparison expression shown in the equivalent-to statements do not meet the BooleanTestable requirements, the behavior is undefined.

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) Same as (1), except that rhs is a 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.

9) Same as (7), except that rhs is a 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.

Parameters

Return value

1,8) true if std::get<i>(lhs) == std::get<i>(rhs) for all i in [0, sizeof...(Types)), otherwise false. For two empty tuples returns true.

2) !(lhs == rhs)

3) true if the first non-equivalent element in lhs is less than the one in rhs, false if the first non-equivalent element in rhs is less than the one in lhs or there is no non-equivalent element. For two empty tuples, returns false.

4) !(rhs < lhs)

5) rhs < lhs

6) !(lhs < rhs)

Notes

Example

#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 }

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

See also