Iterating on a tuple... again

Question

It's been a while that I've been doing C++ but I'm not familiar with templates.

Recently, I tried to write a class that wrap a std::vector<std::tuple<Types...>>. This class must have member functions, and I really need to be able to iterate over the tuple. In fact, if I am able to print every element of a tuple (in the order), I would be able to do everything I need.

I found a solution using a cast, but I'm not really confident with it since it is based on a cast that I don't really like (plus, when I try to use static_cast, it doesn't compile anymore).

My question is, is the following code correct, portable, is it a hack and should I find another way to do this than to use this cast ? Also, this cast is probably a runtime-cast right ? Is there a way to do what I want without this ?

std::ostream& operator<<(std::ostream& out, std::tuple<> const& tuple)
{
    return out; // Nothing to do here
}

template<typename First, typename... Types>
std::ostream& operator<<(std::ostream& out, std::tuple<First, Types...> const& tuple)
{
    out << std::get<0>(tuple) << " ";

    // The cast that I don't like
    return out << (std::tuple<Types...>&) tuple;
}

int main()
{
    auto tuple = std::make_tuple(1, 2.3, "Hello");
    std::cout << tuple << std::endl;
    return 0;
}

Thank you in advance for your answers.

This even [produces a segfault](http://coliru.stacked-crooked.com/a/9f96f1e786b070f1) when using clang++ & libc++ — dyp, Feb 15 '15 at 21:40
I suggest also having a look at Boost.Fusion (esp. `for_each`). It may or may not be overkill, but it certainly is easier to write. — Quentin, Feb 16 '15 at 14:44

score 11 · Accepted Answer · edited May 23 '17 at 12:22

11

Use std::index_sequence_for for fun and profit.

template <typename TupleLike, size_t ... Inds>
std::ostream& PrintHelper(std::ostream& out, TupleLike const& tuple, std::index_sequence<Inds...>)
{
  int unused[] = {0, (void(out << std::get<Inds>(tuple) << " "), 0)...};
  (void)unused;
  return out;
}

template<typename... Types>
std::ostream& operator<<(std::ostream& out, std::tuple<Types...> const& tuple)
{
  return PrintHelper(out, tuple, std::index_sequence_for<Types...>());
}

EDIT : Live Demo. Thanks to @dyp. This uses an expansion trick from this answer.

edited May 23 '17 at 12:22

Community

1
1

answered Feb 15 '15 at 21:40

Pradhan

16,391
3
44
59

Note that this causes stack corruption on MSVC, but the equivalent using `std::array<>` works fine. – ildjarn Feb 21 '15 at 05:16
1

VC++ 2015 has fixed the stack corruption issue. – ildjarn Jul 24 '15 at 05:16

tforgione · Answer 2 · 2015-02-16T13:03:00.277

I found another way to do what I want. I used this article that can print the elements of a tuple in the descending order, and I use a second index J == std::tuple_size<std::tuple<Types...>>::value - I so I can specialize the template when I==0.

template<std::size_t I, std::size_t J, typename... Types>
struct printHelper
{
    std::ostream& operator()(std::ostream& out, std::tuple<Types...> const& tuple)
    {
        out << std::get<J>(tuple) << " ";

        // Recursive call without cast
        return printHelper<I-1,J+1,Types...>{}(out, tuple);
    };
};

// Specialization on the last element when I==0
template<std::size_t J, typename... Types>
struct printHelper<0,J,Types...>
{
    std::ostream& operator()(std::ostream& out, std::tuple<Types...> const& tuple)
    {
        // Nothing to do here
        return out;
    }
};

template<typename... Types>
std::ostream& operator<<(std::ostream& out, std::tuple<Types...> const& tuple)
{
    return printHelper<std::tuple_size<std::tuple<Types...>>::value, 0, Types...>{}(out, tuple);
}

Iterating on a tuple... again

2 Answers2

Linked

Related