C++ 为多个元组的每个第n个参数调用lambda？

我正试图编写一个代码，用从一组可变元组中提取的输入参数调用lambda。但是，我的尝试没有编译：

#include <iostream>
#include <tuple>
#include <utility>
#include <type_traits>

template <typename ...>
struct first_of;

template <typename T, typename ... Args>
struct first_of<T, Args...> {
    using type = std::decay_t<T>;
};

template <typename T>
struct first_of<T> {
    using type = std::decay_t<T>;
};

template <typename ... T>
using first_of_t = typename first_of<T...>::type;

template <typename Fn, typename... Tuples, std::size_t... Idxs>
void run_impl(Fn&& fn, std::index_sequence<Idxs...>, Tuples... t) {
  auto temp = {(fn(std::get<Idxs>(t)...), true)...};
  (void)temp;
}

template <typename Fn, typename... Tuples>
void run(Fn&& fn, Tuples&&... tuples) {
  run_impl(std::forward<Fn>(fn), std::make_index_sequence<std::tuple_size<first_of_t<Tuples...>>::value>{}, std::forward<Tuples>(tuples)...);
}

int main() {
    auto a = std::make_tuple(1, 2.34, "one");
    auto b = std::make_tuple(32, 5.34, "two");

    auto print = [](auto& f, auto& g) { std::cout << f << ", " << g << std::endl; };
    run(print, a, b);
}

#包括
#包括
#包括
#包括
模板
结构第一单元；
模板
结构第一单元{
使用类型=标准：：衰减\u t；
};
模板
结构第一单元{
使用类型=标准：：衰减\u t；
};
模板
使用first_of_t=typename first_of:：type；
模板
void run_impl（Fn&&Fn，std:：index_序列，元组…t）{
自动温度={（fn（std:：get（t）…），真）…}；
（无效）温度；
}
模板
无效运行（Fn&&Fn，元组&&…元组）{
运行impl（std:：forward（fn），std:：make_index_sequence{}，std:：forward（tuples）…）；
}
int main（）{
自动a=std:：make_tuple（1,2.34，“一”）；
auto b=std:：make_tuple（32,5.34，“2”）；
auto print=[]（auto&f，auto&g）{std:：cout最简单的方法是添加另一层间接寻址，让
运行_impl
委托给另一个执行实际调用的函数。我冒昧地将您的函数重命名为
调用_transposed（）
：

模板
用n（Fn&&Fn，元组&&t）无效调用{
fn（std：：get（std：：forward（t））…）；
}
模板
void call_transposed_impl（Fn&&Fn，std:：index_序列，元组&&t）{
auto temp={（用n（fn，std:：forward（t）…）调用n，true）…}；
（无效）温度；
}
模板
void call_转置（Fn&&Fn，元组&&…元组）{
调换呼叫(
标准：正向（fn），
std:：make_index_sequence{}，
std:：forward（元组）；
}


我不确定为什么您的代码不起作用，但我怀疑
std:：get（t）…
正试图同时扩展两个包
Idxs
和
t
，这样以后就没有包可扩展了。这段代码通过一次只处理一个包来避免问题。
谢谢，我实际上实现了类似std:：apply的东西，并将参数作为元组传递，效果很好（这也是另一个间接层次），但您的解决方案要整洁得多。
template <std::size_t I, typename Fn, typename... Tuples>
void call_with_nth(Fn&& fn, Tuples&&... t) {
    fn(std::get<I>(std::forward<Tuples>(t))...);
}

template <typename Fn, std::size_t... Idxs, typename... Tuples>
void call_transposed_impl(Fn&& fn, std::index_sequence<Idxs...>, Tuples&&... t) {
  auto temp = {(call_with_nth<Idxs>(fn, std::forward<Tuples>(t)...), true)...};
  (void)temp;
}

template <typename Fn, typename... Tuples>
void call_transposed(Fn&& fn, Tuples&&... tuples) {
  call_transposed_impl(
      std::forward<Fn>(fn),
      std::make_index_sequence<std::tuple_size<first_of_t<Tuples...>>::value>{},
      std::forward<Tuples>(tuples)...);
}