一种方法是编写 Haskell 意义上的函子。嗯，一个可变的，不是很 Haskell。
写一个签名函数(Ts...)->( ((Ts...)->X) -> X )。即一个接受一个包并返回一个函数的函数。返回的函数可以采用一个函数来获取该包并对其进行评估。
template<class...Ts>
auto make_functor(Ts&&...ts); // TODO
一旦有了，我们就可以轻松解决您的问题。
template<class ...A>
auto test(A&& ...a) {
return [unpack_a=make_functor(std::forward<A>(a)...)]() mutable
{
return unpack_a([&](auto&&...a){
// here you have access to a...
return sizeof...(a);
});
};
}
test 接受一个包，并返回一个返回该包大小的函数（嗯，对包做任何事情）。
make_functor 并不容易：基本上，我们编写一个手动 lambda，将 args 存储在一个元组中，然后在运算符 () 中解压缩索引技巧。
实际上，我们在手动的伪 lambda 类中进行一次包存储和解包一次，然后可以在以后重用它。
再想一想，最好写一个延迟应用，它接受一个元组，存储它，然后再使用std::apply。
template<class...Ts>
auto delayed_apply(std::tuple<Ts...> tup){
return [tup=std::move(tup)](auto&&f)->decltype(auto) mutable{
return std::experimental::apply(decltype(f)(f), std::move(tup));
};
}
让参数的值/引用不会丢失！
template<class ...A>
auto test(A&& ...a) {
return [unpack_a=delayed_apply(std::forward_as_tuple(std::forward<A>(a)...))]() mutable
{
return unpack_a([&](auto&&...a){
// here you have access to a...
return sizeof...(a);
});
};
}
这确实需要std::experimental::apply。
如果您想存储右值并将左值作为参考：
unpack_a=delayed_apply(std::tuple<A...>(std::forward<A>(a)...))
如果你想同时存储 l 和 r 值：
unpack_a=delayed_apply(std::make_tuple(std::forward<A>(a)...))
如您所见，这种方法提供了很多控制。
如果您需要std::experimental::apply，这里有参考实现：比我在智能手机上写的任何东西都要好。
请注意，make_functor 可以写成delayed_apply，但相反的是……不正确。
如果您感到困惑，unpack_a 接受一个 lambda 并将用于创建 unpack_a 的元组解包到其中。基本上，我们将一个对象存储为整个包，然后在需要时将其解包到 lambda 的主体中。
如果您希望解包有时“不止一次”工作，有时“只工作一次”，可能需要更长的delayed_apply 来处理 const 和非 const 甚至右值重载。它必须返回一个类，而不是 lambda。恼人的。使示例代码工作，我认为，仍然没有编译。
幸好这种东西是一次写，用多次。