我实际上对同一件事有点兴趣（想根据最终参数专门化模板化参数包）。
我相信通过结合元组反转（std::make_tuple，后向端口std::apply 用于 C++14 等）可能会有一条前进的道路：
如果成功了会回到这里。
相关帖子：
编辑：
是的，过了一会儿想通了；不完美，因为有额外的副本飞来飞去，但这是一个开始。
如果您知道比我在下面列出的更简单的方法，请不要犹豫发布！
TL;DR
可以做这样的事情：
auto my_func_callable = [] (auto&& ... args) {
return my_func(std::forward<decltype(args)>(args)...);
};
auto my_func_reversed =
stdcustom::make_callable_reversed(my_func_callable);
然后实现这个伪代码：
template<typename ... Args>
void my_func(Args&& ... args, const my_special_types& x);
通过执行以下操作：
template<typename... Args>
void my_func(Args&& ... args)
-> call my_func_reversed(args...)
template<typename... RevArgs>
void my_func_reversed(const my_special_types& x, RevArgs&&... revargs)
-> do separate things with revargs and my_special_types
-> sub_func_reversed(revargs...)
使用上述实用程序。
有一些（很多）缺点。将在下面列出。
范围
这是为 C++14（可能是 C++11）的用户准备的，他们想从未来（C++17）中借鉴。
第 1 步：反转参数
有几种不同的方法可以做到这一点。我在这个例子中列出了一些替代方案：
-
tuple.cc - 两个替代方案的游乐场（源代码中的学分）：
- 使用可折叠表达式并操作通过
std::apply_impl 传递的索引（来源：Orient）。
- 使用递归模板构造一个反向的
index_sequence（来源：Xeo）
-
tuple.output.txt - 示例输出
-
这会打印出 Xeo 示例中的 reversed_index_sequence 模板。我需要这个来调试。
>>> name_trait<std::make_index_sequence<5>>::name()
std::index_sequence<0, 1, 2, 3, 4>
>>> name_trait<make_reversed_index_sequence<5>>::name()
std::index_sequence<4, 3, 2, 1, 0>
我选择了备选方案 1，因为它更容易消化。
然后我尝试快速将其正式化：
定义片段（改编自 cppreference.com 上 std::apply 的 C++17 可能实现）：
namespace detail {
template <class F, class Tuple, std::size_t... I>
constexpr decltype(auto) apply_reversed_impl(F &&f,
Tuple &&t, std::index_sequence<I...>)
{
// @ref https://stackoverflow.com/a/31044718/7829525
// Credit: Orient
constexpr std::size_t back_index = sizeof...(I) - 1;
return f(std::get<back_index - I>(std::forward<Tuple>(t))...);
}
} // namespace detail
template <class F, class Tuple>
constexpr decltype(auto) apply_reversed(F &&f, Tuple &&t)
{
// Pass sequence by value to permit template inference
// to parse indices as parameter pack
return detail::apply_reversed_impl(
std::forward<F>(f), std::forward<Tuple>(t),
std::make_index_sequence<
std::tuple_size<std::decay_t<Tuple>>::value>{});
}
用法片段：（来自tuple_future_main.output.txt，从上面复制）
auto my_func_callable = [] (auto&& ... args) {
return my_func(std::forward<decltype(args)>(args)...);
};
auto my_func_reversed =
stdcustom::make_callable_reversed(my_func_callable);
第 2 步：扣鞋（使用反向参数包）
首先，为您希望使用的最终参数建立模式。您必须明确列举这些，因为您只能有一个参数包。
（取自tuple_future_main.cc）：
示例场景：
我们喜欢将东西添加到具有名称的容器中，例如：
add_item(const Item& item, const string& name, Container& c)
我们还可以构造一个具有 [非常大] 数量的重载的 Item，并且
我们有方便的重载：
add_item(${ITEM_CTOR_ARGS}, const string& name, Container& c)
为此，我们可以声明以下内容：
void add_item_direct(const Item& item, const string& name, Container& c)
Item create_item(Args&&... args)
然后定义我们的通用接口：
template<typename... Args>
void add_item(Args&&... args) {
...
auto reversed = stdcustom::make_callable_reversed(callable);
reversed(std::forward<Args>(args)...);
}
template<typename ... RevArgs>
void add_item_reversed(Container& c, const string& name, RevArgs&&... revargs)
{
...
static auto ctor = VARIADIC_CALLABLE(create_item,);
...
auto item = ctor_reversed(std::forward<RevArgs>(revargs)...);
add_item_direct(item, name, c);
}
现在我们可以执行以下操作：（取自tuple_future_main.output.txt）
>>> (add_item(Item("attribute", 12), "bob", c));
>>> (add_item("attribute", 12, "bob", c));
>>> (add_item(Item(2, 2.5, "twelve"), "george", c));
>>> (add_item(2, 2.5, "twelve", "george", c));
>>> (add_item(Item(2, 15.), "again", c));
>>> (add_item(2, 15., "again", c));
>>> c
bob - ctor3: ctor3: ctor1: attribute (12, 10)
bob - ctor3: ctor1: attribute (12, 10)
george - ctor3: ctor3: ctor2: 2, 2.5 (twelve)
george - ctor3: ctor2: 2, 2.5 (twelve)
again - ctor3: ctor3: ctor2: 2, 15 ()
again - ctor3: ctor2: 2, 15 ()
注意额外的复制构造函数... :(
缺点
- 丑得要命
- 可能没用
- 重构你的接口可能更容易
- 但是，这可以用作过渡到更通用界面的权宜之计。
- 可能要删除的行数更少。
- 尤其是当它在您的开发过程中插入模板爆炸时
- 无法确定额外副本的来源。
- 您必须精心设计基础功能
- 您不应尝试扩展现有函数。
- 参数包会贪婪地匹配函数
- 您要么需要明确说明您想要的每个重载，要么弯下腰让可变参数包分派到您想要的功能
- 模板错误很糟糕。
- 在 lambda 中封装了许多简单的功能
- 您也许可以使用
make_reversed_index_sequence 并直接调度到函数（在其他 SO 帖子中提到）。但这重复起来很痛苦。
待办事项
- 摆脱多余的副本
- 尽量减少对所有 lambda 的需求
-
尝试对抗参数包贪婪
-
是否有一个通用的std::enable_if 匹配同时匹配左值和右值引用，并且可能处理转发兼容的隐式复制构造函数？
template<typename ... Args>
void my_func(Args&& ... args) // Greedy
void my_func(magical_ref_match<string>::type, ...)
// If this could somehow automatically snatch `const T&` and `T&&` from the parameter pack...
// And if it can be used flexible with multiple arguments, combinatorically
希望
- 也许 C++17 将支持非最终参数包参数，这样所有这些都可以被丢弃...... 手指交叉