Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://en.cppreference.com/w/cpp/language/../utility/tuple/operator_cmp.html below:

operator==,!=,<,<=,>,>=,<=>(std::tuple) - cppreference.com

template< class... TTypes, tuple-like UTuple >
constexpr bool operator==( const tuple<TTypes...>& lhs, const UTuple& rhs );

1,2) Compares every element of the tuple lhs with the corresponding element of the tuple rhs by operator==.

1) Returns true if all pairs of corresponding elements are equal.

2) Returns !(lhs == rhs).

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

do not meet the

requirements for any

in

, the behavior is undefined.

This overload participates in overload resolution only if

equals

,

is a valid expression and

model

for every

in

.

3-6) Compares lhs and rhs lexicographically by operator<, that is, compares the first elements, if they are equivalent, compares the second elements, if those are equivalent, compares the third elements, and so on.

For empty tuples, returns

. For non-empty tuples, the effect is equivalent to

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

requirements, the behavior is undefined.

Compares

and

lexicographically by

, that is, compares the first elements, if they are equivalent, compares the second elements, if those are equivalent, compares the third elements, and so on.

• For empty tuples, returns std::strong_ordering::equal.
• For non-empty tuples, the effect is equivalent to

All comparison operators are short-circuited; they do not access tuple elements beyond what is necessary to determine the result of the comparison.

The <, <=, >, >=, and != operators are synthesized from operator<=> and operator== respectively.

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)

The relational operators are defined in terms of each element's operator<.

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<.

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 }

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

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4