Implementing lexicographic comparison for std::tuple in C++11 - c++

Question

I'm trying to implement lexicographic comparison for std::tuple. I know the standard provides this. I'm doing it as a TMP exercise. I can't see why the code below doesn't work. Can anyone point me in the right direction?
I know the code below assumes operands of the same type. I am happy making this as a simplifying assumption.
I've looked at the VC++ 2013 and GCC 4.7 implementations. They both use non-standard helper classes to get the tail (i.e. all but the left-most element) from a tuple. I'd like to solve the problem with as little scaffolding as possible. Is it possible to do tuple comparison without something like get_tail?
#include <iostream>
#include <string>
#include <tuple>
// Pseudo-recursion.
template<class tupleT,std::size_t N>
struct tuple_ops {
static bool less(const tupleT& x,const tupleT& y) {
return std::get<N-1>(x) < std::get<N-1>(y) ||
( !(std::get<N-1>(y) < std::get<N-1>(x)) &&
tuple_ops<tupleT,N-1>::less(x,y) );
}
};
// Base Case.
template<class tupleT>
struct tuple_ops<tupleT,1> {
static bool less(const tupleT& x,const tupleT& y) {
return std::get<0>(x) < std::get<0>(y);
}
};
// Convenience wrapper.
template<class... T>
bool operator<(const std::tuple<T...>& x,const std::tuple<T...>& y) {
return tuple_ops<decltype(x),sizeof...(T)>::less(x,y);
}
int main() {
using namespace std;
auto tup0 = make_tuple(3.14,string("foo"),2.71);
auto tup1 = make_tuple(4.01,string("foo"),2.01);
auto tup2 = make_tuple(1,string("bar"),5);
auto tup3 = make_tuple(1,string("foo"),5);
cout << (::operator<(tup0,tup1)) << ' '
<< (::operator<(tup2,tup3)) << ' '
<< !(::operator<(tup1,tup0)) << ' '
<< !(::operator<(tup3,tup2)) << ' ';
return 0;
}
Output: 0 1 0 1
Correct output would be: 1 1 1 1
Thanks in advance.

Answer 1

The reason your code doesn't work is that your comparisons are backwards. Your first call is:
return tuple_ops<decltype(x),sizeof...(T)>::less(x,y);
which will call tuple_ops<Type, 3>::less(), the first operation of which compares std::get<2>(x) and std::get<2>(y). So you're comparing the last elements first.
You have to start at 0 and go up to N, so you'd have to rewrite your first-level call to be:
return tuple_ops<decltype(x),0,sizeof...(T)>::less(x,y);
with the terminating case now being:
template <typename Tuple, size_t N>
struct tuple_ops<Tuple, N, N> {
static bool less(const Tuple&, const Tuple&) { return false; }
};
A simpler way to avoid specializations would be to use an index sequence (and borrowing from Yakk's now-deleted answer to add more functionality):
template <class X, class Y>
bool operator<(const X& x, const Y& y) {
return is_less(x, y,
std::make_index_sequence<std::min(std::tuple_size<X>{},
std::tuple_size<Y>{})>{});
}
Have an overload for the empty case:
template <typename X, typename Y>
bool is_less(X const&, Y const&, std::index_sequence<> ) {
return std::tuple_size<X>{} < std::tuple_size<Y>{};
}
and an overload for the recursive case:
template <typename X, typenmae Y, size_t I, size_t... Is>
bool is_less(X const& x, Y const& y, std::index_sequence<I, Is...> ) {
if (std::get<I>(x) < std::get<I>(y)) {
return true;
}
else if (std::get<I>(y) < std::get<I>(x)) {
return false;
}
else {
return is_less(x, y, std::index_sequence<Is...>{});
}
}

Answer 2

Working like a charm. Here's a version of the test program, incorporating Barry's tips.
#include <iostream>
#include <string>
#include <tuple>
// Pseudo-recursion.
template<class tupleT,std::size_t J,std::size_t N>
struct tuple_ops {
static bool less(const tupleT& x,const tupleT& y) {
return std::get<J>(x) < std::get<J>(y) ||
( !(std::get<J>(y) < std::get<J>(x)) &&
tuple_ops<tupleT,J+1,N>::less(x,y) );
}
};
// Base Case.
template <typename Tuple, size_t N>
struct tuple_ops<Tuple,N,N> {
static bool less(const Tuple&, const Tuple&) {return false;}
};
// Convenience wrapper.
template<class... T>
bool operator<(const std::tuple<T...>& x,const std::tuple<T...>& y) {
return tuple_ops<decltype(x),0,sizeof...(T)>::less(x,y);
}
int main() {
using namespace std;
auto tup0 = make_tuple(3.14,string("foo"),2.71);
auto tup1 = make_tuple(4.01,string("foo"),2.01);
auto tup2 = make_tuple(1,string("bar"),5);
auto tup3 = make_tuple(1,string("foo"),5);
cout << (::operator<(tup0,tup1)) << ' '
<< (::operator<(tup2,tup3)) << ' '
<< !(::operator<(tup1,tup0)) << ' '
<< !(::operator<(tup3,tup2)) << ' ';
return 0;
}
Thanks again.