模板参数和 std：：函数参数的演绎

Question

假设有一个模板函数 foo（） 接受任意数量的参数。给定最后一个参数始终是 std：：函数，我如何实现下面显示的 foo（） 模板，以便 CbArgs 包含此 std：：function 的参数？

template<typename... InArgs, typename... CbArgs = ???>
//                                       ^^^^^^^^^^^^
void foo(InArgs... args) { ... }

例如，如果像这样调用，CbArgs应该是{int，int}：

std::function<void(int,int)> cb;
foo(5, "hello", cb);

我的第一个想法是：

template<typename... InArgs, typename... CbArgs>
void foo(InArgs... args, std::function<void(CbArgs...)>) { ... }

但这不会编译：

note:   template argument deduction/substitution failed:
note:   mismatched types ‘std::function<void(CbArgs ...)>’ and ‘int’
  foo(5, "hello", cb);

问题一：
为什么这不能编译？为什么模板参数演绎失败？

最终，我想出了这个解决方案：

template<typename... InArgs, typename... CbArgs>
void fooImpl(std::function<void(CbArgs...)>, InArgs... args) { ... }

template<typename... InArgs,
         typename CbType = typename std::tuple_element_t<sizeof...(InArgs)-1, std::tuple<InArgs...>>>
void foo(InArgs... args)
{
    fooImpl(CbType{}, args...);
}

这里，CbType是InArgs，即std:：function中的最后一种类型。然后，CbType的临时值被传递到fooImpl（），其中CbArgs。这行得通，但在我看来很难看。

问题二：
我想知道如果没有两个函数和CbType的临时实例，是否有更好的解决方案？

Answer 1

这个为什么不编译？模板参数推演为什么会失败？

当参数包不是最后一个参数时，无法推导它。告诉编译器InArgs...的内容将使您的foo定义工作：

template<typename... InArgs, typename... CbArgs>
void foo(InArgs..., std::function<void(CbArgs...)>) { }

int main()
{
    std::function<void(int,int)> cb;
    foo<int, const char*>(5, "hello", cb);
}

或者，正如您在解决方法中发现的那样，只需将InArgs...放在末尾并更新您的foo调用：

template<typename... InArgs, typename... CbArgs>
void foo(std::function<void(CbArgs...)>, InArgs...) { }

int main()
{
    std::function<void(int,int)> cb;
    foo(cb, 5, "hello");
}

我想知道如果没有两个函数和＜code＞CbType＜/code＞的临时实例，是否有更好的解决方案？

这里有一种可能的方法可以避免不必要的临时实例，但使用相同的机制来推导CbArgs…：只需将CbType包装在一个空包装器中，然后将其传递给fooImpl。

template <typename T>
struct type_wrapper
{
    using type = T;
};

template<typename... InArgs, typename... CbArgs>
void fooImpl(type_wrapper<std::function<void(CbArgs...)>>, InArgs&&...) { }

template<typename... InArgs,
         typename CbType = 
             std::tuple_element_t<sizeof...(InArgs)-1, 
                 std::tuple<std::remove_reference_t<InArgs>...>>>
void foo(InArgs&&... args)
{
    fooImpl(type_wrapper<CbType>{}, std::forward<InArgs>(args)...);
}

其他改进：

>

typename.CbType=之后的typename，是不必要的-它被删除了。

< code >参数...应该完全转发到< code>fooImpl以保留其值类别。< code>foo和< code>fooImpl都应该采用< code >参数...作为转发参考。

Wandbox示例

请注意，有一个建议可以使处理非终端参数包更容易：P0478R0-“非终端函数参数包的模板参数推导”。这将使您的原始实现按预期工作。