Template function binding variadic number of tuple's elements to another function as arguments

Question

Is there any way in c++11/14 to write variadic template function like this:

template <typename ReturnType, typename Args...>
std::function<ReturnType()> bindArgumentsFromTuple
                                  (std::function<ReturnType(Args... args)> f,
                                  const std::tuple<Args...>& t)

that binds elements of tuple t to function f as arguments (such that the number of elements and its types are identical in function arguments and tuple)?

Example of usage:

void dummy_print(int i, double d)
{
    std::cout << i << "," << d << '\n';
}
void dummy_print2(int i, double d, std::string& s)
{
    std::cout << i << "," << d <<  "," << s << '\n';
}

int main() {
    std::tuple<int,double> t(77,1.1);
    std::tuple<int,double,std::string> t2(1,2.0,"aaa");
    auto f1 = bindArgumentsFromTuple(dummy_print, t);
    f1();
    auto f2 = bindArgumentsFromTuple(dummy_print2, t2);
    f2();

    return 0;
}

score 3 · Accepted Answer · answered Jan 12 '16 at 13:37

3

template <typename F, typename T, std::size_t... indices>
auto bindTuple(F&& f, T&& t, std::index_sequence<indices...>) {
    return std::bind(std::forward<F>(f), std::get<indices>(std::forward<T>(t))...);
}

template <typename F, typename T>
auto bindTuple(F&& f, T&& t) {
    return bindTuple(std::forward<F>(f), std::forward<T>(t),
                   std::make_index_sequence<std::tuple_size<std::decay_t<T>>{}>{});
}

The above will support anything tuple-esque, i.e. std::array, std::tuple, etc., while regarding placeholder arguments. Demo.

answered Jan 12 '16 at 13:37

Columbo

60,038
8
155
203

Thank you! It is my one more knowledge gap in c++: `std::index_sequence` :) – attuda Jan 12 '16 at 13:49
In the first overload wouldn't you be forwarding `t` (potentially moving it) multiple times? – David G Jan 12 '16 at 14:09
2

@0x499602D2 I'm forwarding it so `std::get` can forward the tuple's elements accordingly, avoiding copies whenever possible – Columbo Jan 12 '16 at 14:11
With STL's usual caveat about `bind` doing extra magic that may or may not be desirable. – T.C. Jan 12 '16 at 20:15
@T.C. You mean *INVOKE*? – Columbo Jan 13 '16 at 16:20
@Columbo INVOKE is fine, the handling of nested binds is the major issue. – T.C. Jan 13 '16 at 17:04

score 1 · Answer 2 · answered Jan 12 '16 at 13:37

1

With std::index_sequence, you may do something like:

template <typename ReturnType, typename ...Args, std::size_t ... Is>
std::function<ReturnType()>
bindArgumentsFromTuple_impl(std::function<ReturnType(Args...)> f,
                       const std::tuple<Args...>& t, std::index_sequence<Is...>)
{
    return [=]() { return f(std::get<Is>(t)...);};
}

template <typename ReturnType, typename ...Args>
std::function<ReturnType()>
bindArgumentsFromTuple(std::function<ReturnType(Args...)> f,
                       const std::tuple<Args...>& t)
{
    return bindArgumentsFromTuple_impl(f, t, std::index_sequence_for<Args...>{});
}

Live Demo

answered Jan 12 '16 at 13:37

Jarod42

203,559
14
181
302

1

`std::function`? Seriously? – Columbo Jan 12 '16 at 13:42
I kept OP's signature, but your are right, your way is better. – Jarod42 Jan 12 '16 at 13:46
2

The OP accepts `string`s with non-const references; I doubt he knows what's best for him :-) – Columbo Jan 12 '16 at 13:48
Thank you! As I wrote to @Colombo, it is my another knowledge gap in c++: std::index_sequence :) – attuda Jan 12 '16 at 13:50
1

@attuda: You can't accept several answers, but you can up vote several answers. – Jarod42 Jan 12 '16 at 14:09

Template function binding variadic number of tuple's elements to another function as arguments

2 Answers2