How can you iterate over the elements of an std::tuple?

by

I have an answer based on Iterating over a Tuple:

#include <tuple>
#include <utility> 
#include <iostream>

template<std::size_t I = 0, typename... Tp>
inline typename std::enable_if<I == sizeof...(Tp), void>::type
  print(std::tuple<Tp...>& t)
  { }

template<std::size_t I = 0, typename... Tp>
inline typename std::enable_if<I < sizeof...(Tp), void>::type
  print(std::tuple<Tp...>& t)
  {
    std::cout << std::get<I>(t) << std::endl;
    print<I + 1, Tp...>(t);
  }

int
main()
{
  typedef std::tuple<int, float, double> T;
  T t = std::make_tuple(2, 3.14159F, 2345.678);

  print(t);
}

The usual idea is to use compile time recursion. In fact, this idea is used to make a printf that is type safe as noted in the original tuple papers.

This can be easily generalized into a for_each for tuples:

#include <tuple>
#include <utility> 

template<std::size_t I = 0, typename FuncT, typename... Tp>
inline typename std::enable_if<I == sizeof...(Tp), void>::type
  for_each(std::tuple<Tp...> &, FuncT) // Unused arguments are given no names.
  { }

template<std::size_t I = 0, typename FuncT, typename... Tp>
inline typename std::enable_if<I < sizeof...(Tp), void>::type
  for_each(std::tuple<Tp...>& t, FuncT f)
  {
    f(std::get<I>(t));
    for_each<I + 1, FuncT, Tp...>(t, f);
  }

Though this then requires some effort to have FuncT represent something with the appropriate overloads for every type the tuple might contain. This works best if you know all the tuple elements will share a common base class or something similar.

More Related Contents:

  1. How to make generic computations over heterogeneous argument packs of a variadic template function?
  2. Creating an array initializer from a tuple or variadic template parameters
  3. Checking a member exists, possibly in a base class, C++11 version
  4. void_t “can implement concepts”?
  5. Why is it not good to use recursive inheritance for std::tuple implementations?
  6. C++11 “overloaded lambda” with variadic template and variable capture
  7. TMP: how to generalize a Cartesian Product of Vectors?
  8. constexpr initialization of array to sort contents
  9. C++ std::tuple order of destruction
  10. Generating one class member per variadic template argument
  11. “What happened to my SFINAE” redux: conditional template class members?
  12. Concatenate compile-time strings in a template at compile time?
  13. How to enable C++11/C++0x support in Eclipse CDT?
  14. Why are preprocessor macros evil and what are the alternatives?
  15. How do I call ::std::make_shared on a class with only protected or private constructors?
  16. How to code a modulo (%) operator in C/C++/Obj-C that handles negative numbers
  17. Generic hash for tuples in unordered_map / unordered_set
  18. Implementing 64 bit atomic counter with 32 bit atomics
  19. Using regex lookbehinds in C++11
  20. Check at Compile-Time if Template Argument is void
  21. Are multiple mutations within initializer lists undefined behavior?
  22. Why is std::unordered_map slow, and can I use it more effectively to alleviate that?
  23. C++0x thread interruption
  24. Deducing first template argument with other template parameters defaulted
  25. Refactoring with C++ 11
  26. How do I erase elements from STL containers?
  27. How to initialize `std::function` with a member-function?
  28. error::make_unique is not a member of ‘std’
  29. weak_ptr, make_shared and memory deallocation
  30. Questions regarding C++ non-POD unions

Leave a Comment