模板函数结合元组的元素的可变参数数到另一个函数作为参数

Question

是否有在C++中的任何方式14分之11写可变参数模板函数是这样的：

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

结合的元组吨元件起作用f作为参数（例如，元素的数量及其类型在函数参数和元组中是相同的）？用法

例子：

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; 
} 

Answer 1

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>>{}>{}); 
} 

以上将支持任何元组式的，即std::array ，std::tuple等，而关于placeh较旧的论点。 Demo。

Answer 2

随着std::index_sequence，你可以这样做：

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