Can someone please explain the “indices trick”?

by

The problem is: we have a std::tuple<T1, T2, ...> and we have some function f that we can to call on each element, where f returns an int, and we want to store those results in an array.

Let’s start with a concrete case:

template <typename T> int f(T ) { return sizeof(T); }

std::tuple<int, char, double> tup{42, 'x', 3.14};
std::array<int, 3> arr{ f(std::get<0>(tup)), 
                        f(std::get<1>(tup)),
                        f(std::get<2>(tup)) );

Except writing out all those gets is inconvenient and redundant at best, error-prone at worst.

First we need to include the utility header for std::index_sequence and std::make_index_sequence:

#include <utility>

Now, let’s say we had a type index_sequence<0, 1, 2>. We could use that to collapse that array initialization into a variadic pack expansion:

template <typename Tuple, size_t... Indices>
std::array<int, sizeof...(Indices)> 
call_f_detail(Tuple& tuple, std::index_sequence<Indices...> ) {
    return { f(std::get<Indices>(tuple))... };
}

That’s because within the function, f(std::get<Indices>(tuple))... gets expanded to f(std::get<0>(tuple)), f(std::get<1>(tuple)), f(std::get<2>(tuple)). Which is exactly what we want.

The last detail of the problem is just generating that particular index sequence. C++14 actually gives us such a utility named make_index_sequence

template <typename Tuple>
std::array<int, std::tuple_size<Tuple>::value>
call_f(Tuple& tuple) {
    return call_f_detail(tuple,
        // make the sequence type sequence<0, 1, 2, ..., N-1>
        std::make_index_sequence<std::tuple_size<Tuple>::value>{}
        );
}

whereas the article you linked simply explains how one might implement such a metafunction.

Bare is probably something like, from Luc Danton’s answer:

template<typename T>
using Bare = typename std::remove_cv<typename std::remove_reference<T>::type>::type;

More Related Contents:

  1. Pretty-print std::tuple
  2. how to avoid undefined execution order for the constructors when using std::make_tuple
  3. “unpacking” a tuple to call a matching function pointer
  4. How do I expand a tuple into variadic template function’s arguments?
  5. Variadic template pack expansion
  6. How to call a function on all variadic template args?
  7. C++11: I can go from multiple args to tuple, but can I go from tuple to multiple args? [duplicate]
  8. What are the rules for the “…” token in the context of variadic templates?
  9. check variadic templates parameters for uniqueness
  10. Template tuple – calling a function on each element
  11. Calling a function for each variadic template argument and an array
  12. How to store variadic template arguments?
  13. How to make generic computations over heterogeneous argument packs of a variadic template function?
  14. What is the meaning of “… …” token? i.e. double ellipsis operator on parameter pack
  15. What does this variadic template code do?
  16. Expansion with variadic templates [duplicate]
  17. Variadic templates
  18. C++11 “overloaded lambda” with variadic template and variable capture
  19. What is the easiest way to print a variadic parameter pack using std::ostream?
  20. Check traits for all variadic template arguments
  21. How can I iterate over a packed variadic template argument list?
  22. Variadic function template with pack expansion not in last parameter
  23. generic member function pointer as a template parameter
  24. How to iterate over a std::tuple in C++ 11 [duplicate]
  25. std::tuple get() member function
  26. Generating one class member per variadic template argument
  27. std::tuple memory alignment
  28. Is there a way to write make_unique() in VS2012?
  29. How to combine std::bind(), variadic templates, and perfect forwarding?
  30. How to initialize all tuple elements by the same arguments?

Leave a Comment