Template tuple - calling a function on each element
In C++17 you can do this:
std::apply([](auto ...x){std::make_tuple(some_function(x)...);} , the_tuple);
given that some_function
has suitable overloads for all the types in the tuple.
This already works in Clang++ 3.9, using std::experimental::apply
.
You can quite easily do that with some indices machinery. Given a meta-function gen_seq
for generating compile-time integer sequences (encapsulated by the seq
class template):
namespace detail
{
template<int... Is>
struct seq { };
template<int N, int... Is>
struct gen_seq : gen_seq<N - 1, N - 1, Is...> { };
template<int... Is>
struct gen_seq<0, Is...> : seq<Is...> { };
}
And the following function templates:
#include <tuple>
namespace detail
{
template<typename T, typename F, int... Is>
void for_each(T&& t, F f, seq<Is...>)
{
auto l = { (f(std::get<Is>(t)), 0)... };
}
}
template<typename... Ts, typename F>
void for_each_in_tuple(std::tuple<Ts...> const& t, F f)
{
detail::for_each(t, f, detail::gen_seq<sizeof...(Ts)>());
}
You can use the for_each_in_tuple
function above this way:
#include <string>
#include <iostream>
struct my_functor
{
template<typename T>
void operator () (T&& t)
{
std::cout << t << std::endl;
}
};
int main()
{
std::tuple<int, double, std::string> t(42, 3.14, "Hello World!");
for_each_in_tuple(t, my_functor());
}
Here is a live example.
In your concrete situation, this is how you could use it:
template<typename... Ts>
struct TupleOfVectors
{
std::tuple<std::vector<Ts>...> t;
void do_something_to_each_vec()
{
for_each_in_tuple(t, tuple_vector_functor());
}
struct tuple_vector_functor
{
template<typename T>
void operator () (T const &v)
{
// Do something on the argument vector...
}
};
};
And once again, here is a live example.
Update
If you're using C++14 or later, you can replace the seq
and gen_seq
classes above with std::integer_sequence
like so:
namespace detail
{
template<typename T, typename F, int... Is>
void
for_each(T&& t, F f, std::integer_sequence<int, Is...>)
{
auto l = { (f(std::get<Is>(t)), 0)... };
}
} // namespace detail
template<typename... Ts, typename F>
void
for_each_in_tuple(std::tuple<Ts...> const& t, F f)
{
detail::for_each(t, f, std::make_integer_sequence<int, sizeof...(Ts)>());
}
If you're using C++17 or later you can do this (from this comment below):
std::apply([](auto ...x){std::make_tuple(some_function(x)...);} , the_tuple);
In addition to the answer of @M. Alaggan, if you need to call a function on tuple elements in order of their appearance† in the tuple, in C++17 you can also use a fold expression like this:
std::apply([](auto& ...x){(..., some_function(x));}, the_tuple);
(live example).
†Because otherwise order of evaluation of function arguments is unspecified.