Compare tuples of different sizes

Question

Why isn't it possible to compare two tuples of different size like this:

#include <tuple>
int main() {
  std::tuple<int, int> t1(1, 2);
  std::tuple<int> t2(1);
  if(std::tuple_size<decltype(t1)>::value == std::tuple_size<decltype(t2)>::value)
    return (t1 == t2);
  else
    return 0;
}

I know that t1==t2 is not possible. But in this example it wouldn't be executed. Is there a possibility to compare tuples of different sizes?

The question isn't why it is not possible; the question is why do you want to do so? — CinCout, Aug 14 '15 at 11:36
my question would be: what do you mean with "it isnt possible", what is the error messages. Sorry, I am just too lazy to copy it and find out myself. — 463035818_is_not_an_ai, Aug 14 '15 at 11:37

score 4 · Accepted Answer · edited Jun 20 '20 at 09:12

operator== requires the tuples to be of equal lengths.

§ 20.4.2.7 [tuple.rel]:

template<class... TTypes, class... UTypes>
constexpr bool operator==(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
¹ Requires: For all i, where 0 <= i and i < sizeof...(TTypes), get<i>(t) == get<i>(u) is a valid expression returning a type that is convertible to bool. sizeof...(TTypes) == sizeof...(UTypes).

If you want two tuples of different lengths to be considered unequal, you'd need to implement this logic yourself:

template <typename... Ts, typename... Us>
auto compare(const std::tuple<Ts...>& t1, const std::tuple<Us...>& t2)
    -> typename std::enable_if<sizeof...(Ts) == sizeof...(Us), bool>::type
{
    return t1 == t2;
}

template <typename... Ts, typename... Us>
auto compare(const std::tuple<Ts...>& t1, const std::tuple<Us...>& t2)
    -> typename std::enable_if<sizeof...(Ts) != sizeof...(Us), bool>::type
{
    return false;
}

DEMO

This way, the code comparing two tuples, t1 == t2, is instantiated only when the lengths of tuples match each other. In your scenario, a compiler is unable to compile your code, since there is no predefined operator== for such a case.

score 1 · Answer 2 · answered Aug 14 '15 at 12:04

You may write several overloads:

template<typename ...Ts>
bool is_equal(const std::tuple<Ts...>& lhs, const std::tuple<Ts...>& rhs)
{
    return lhs == rhs;
}

template<typename ...Ts, typename... Us>
bool is_equal(const std::tuple<Ts...>&, const std::tuple<Us...>&)
{
    return false;
}

Live example

score -1 · Answer 3 · edited May 23 '17 at 12:29

-1

You have problem with size mismatch. Read this, maybe it can help you. Implementing comparison operators via 'tuple' and 'tie', a good idea?

edited May 23 '17 at 12:29

Community

1
1

answered Aug 14 '15 at 11:50

Richard Rublev

7,718
16
77
121

I've edited your answer to make the link functional, though this would IMHO be better posted as a comment rather than an answer, since it's essentially a link-only response. – enhzflep Aug 14 '15 at 11:55

Compare tuples of different sizes

3 Answers3