After watching Andrei Alexandrescu’s talk on Going Native 2013, I wanted to take a crack at it myself. The presentation covers how to expand a tuple into individual arguments in a function call. Being a Python programmer I’m a little spoiled by func(*args)
so the ability to do this in C++11 is something I’m eager to use. What I came up with wound up being quite similar, but more flexible. I wanted to make it more generic, to work with std::pair
and std::array
. The version presented in that video is incredibly powerful, but it can go a bit further.
The limitations start at the top level, the explode
free function.
template <class F, class... Ts> auto explode(F&& f, const tuple<Ts...>& t) > typename result_of<F(Ts...)>::type { return Expander<sizeof...(Ts), typename result_of<F(Ts...)>::type, F, const tuple<Ts...>&>::expand(f, t); }
The tuple&
argument allows a means to use result_of
to figure out the return type, and sizeof...
to determine the size of the tuple
itself. This can be accomplished via other means. decltype
can be used to figure out the return type. It needs more typing, but removes the need for result_of
. As for sizeof...
, there is a std::tuple_size
available which can reach the same end. Using this makes explode
nonvariadic. Taking a universal reference, rather than capturing the parameter pack, means different versions for lvalue and rvalue refs aren’t needed.
My initial function (called expand
instead) is:
template <typename Functor, typename Tup> auto expand(Functor&& f, Tup&& tup) > decltype(Expander<std::tuple_size<typename std::remove_reference<Tup>::type>::value, Functor, Tup>::call( std::forward<Functor>(f), std::forward<Tup>(tup))) { return Expander< std::tuple_size<typename std::remove_reference<Tup>::type>::value, Functor, Tup>::call( std::forward<Functor>(f), std::forward<Tup>(tup)); }
Some things to note:

std::tuple_size
works onstd::pair
(yielding 2) and onstd::array
(yielding the size of the array). 
std::get
also supportsstd::pair
andstd::array
, meaning that nowtuple
,pair
, andarray
can all work in this context. 
std::remove_reference
is needed for callingstd::tuple_size
becausetup
is a universal reference, andTup
may deduce to an lvalue reference type
The decltype
goes through each level of the expansion, until much like the original, it hits a base case and does the call.
#include <cstddef> #include <tuple> #include <utility> #include <type_traits> #include <array> template <std::size_t Index, typename Functor, typename Tup> struct Expander { template <typename... Ts> static auto call(Functor&& f, Tup&& tup, Ts&&... args) > decltype(Expander<Index1, Functor, Tup>::call( std::forward<Functor>(f), std::forward<Tup>(tup), std::get<Index1>(tup), std::forward<Ts>(args)...)) { return Expander<Index1, Functor, Tup>::call( std::forward<Functor>(f), std::forward<Tup>(tup), std::get<Index1>(tup), std::forward<Ts>(args)...); } }; template <typename Functor, typename Tup> struct Expander<0, Functor, Tup> { template <typename... Ts> static auto call(Functor&& f, Tup&&, Ts&&... args) > decltype(f(std::forward<Ts>(args)...)) { static_assert( std::tuple_size< typename std::remove_reference<Tup>::type>::value == sizeof...(Ts), "tuple has not been fully expanded"); // actually call the function return f(std::forward<Ts>(args)...); } }; template <typename Functor, typename Tup> auto expand(Functor&& f, Tup&& tup) > decltype(Expander<std::tuple_size< typename std::remove_reference<Tup>::type>::value, Functor, Tup>::call( std::forward<Functor>(f), std::forward<Tup>(tup))) { return Expander<std::tuple_size< typename std::remove_reference<Tup>::type>::value, Functor, Tup>::call( std::forward<Functor>(f), std::forward<Tup>(tup)); }
A few examples showing the flexibility.
int f(int, double, char); int g(const char *, int); int h(int, int, int); int main() { expand(f, std::make_tuple(2, 2.0, '2')); // works with pairs auto p = std::make_pair("hey", 1); expand(g, p); // works with std::arrays std::array<int, 3> arr = {{1,2,3}}; expand(h, arr); }
Each level of the call takes one argument at a time off the back of the tuple
using std::get
and the template Index parameter, decrements the index, and recurses. This is a bit hard to imagine, so I’ll illustrate. This sequence is not meant to be taken too literally.
Let’s say I have a tuple
of string
, int
, char
, and double
. I’ll denote this example tuple as tuple("hello", 3, 'c', 2.0)
. The expansion would happen something like the following
expand(f, tuple("hello", 3, 'c', 2.0)) > call<4>(f, tuple("hello", 3, 'c', 2.0)) > call<3>(f, tuple("hello", 3, 'c', 2.0), 2.0) > call<2>(f, tuple("hello", 3, 'c', 2.0), 'c', 2.0) > call<1>(f, tuple("hello", 3, 'c', 2.0), 3, 'c', 2.0) > call<0>(f, tuple("hello", 3, 'c', 2.0), "hello", 3, 'c', 2.0) > f("hello", 3, 'c', 2.0)
Of course std::integer_sequence
in C++14 turns all of this on its head. Maybe I should’ve implemented that instead…