将函数传递给可变参数函数模板

Question

考虑以下功能模板：

template<typename RetType, typename... ArgTypes>
void foo0(std::function<RetType(ArgTypes...)> f) {}

template<typename RetType, typename ArgType>
void foo1(std::function<RetType(ArgType)> f) {}

并具有以下功能：

void bar(int n) {}

为什么会发生以下情况：

 foo0<void, int>(bar);  // does not compile
 foo1<void, int>(bar);  // compiles fine

编译错误是（gcc-8 with C ++ 17）：

error: no matching function for call to 'foo0<void, int>(void (&)(int))'
   foo0<void, int>(bar);
                      ^
note: candidate: 'template<class RetType, class ... ArgTypes> void foo0(std::function<_Res(_ArgTypes ...)>)'
 void foo0(std::function<RetType(ArgTypes...)> f) {}
      ^~~~
note:   template argument deduction/substitution failed:
note:   mismatched types 'std::function<void(_ArgTypes ...)>' and 'void (*)(int)'
   foo0<void, int>(bar);

使用虚拟模板

template<typename T>
void bar(int n) {}

使foo0<void, int>(bar<int>); 在gcc-8中编译正常，但在使用Apple LLVM 10.0.0版（clang-1000.11.45.5）的clang时出错。

铿锵的错误是

error: no matching function for call to 'foo0'
  foo0<void, int>(bar<int>);
  ^~~~~~~~~~~~~~~
note: candidate template ignored: could not match 'function<void (int, type-parameter-0-1...)>' against 'void (*)(int)'
void foo0(std::function<RetType(ArgTypes...)> f) {}

Answer 1

为什么会出现以下情况[？]

当你打电话时，请记住

 foo0<void, int>(bar); // compilation error
 foo1<void, int>(bar); // compile

foo0()和foo1()期望一个std::function ， bar是一个指向函数的指针，该函数可以转换为std::function但不是std::function 。

在foo1()情况下，您显式显示RetType和ArgType模板参数，因此编译器可以将bar转换为std::function<void(int)> ，一切顺利。

但是foo0()情况是不同的，因为模板参数ArgTypes...是一个可变参数并调用foo0<void, int>(bar)你没有显式完整的ArgTypes... variadic列表但只有第一种类型。

如果我没错，问题是编译器试图从bar参数中推导出其余的ArgTypes...但是bar不是std::function因此编译器无法推断出其余的ArgTypes... ，这样的错误。

我想

foo0<void, int>(std::function<void(int)>{bar});

或者干脆

foo0(std::function<void(int)>{bar});

或者（仅限C ++ 17）

foo0(std::function{bar});

应该编译因为，这样调用foo0() ，函数接收一个std::function这样编译器就可以完全推导出模板参数。

我不明白带有虚拟模板参数的bar()的版本如何

foo0<void, int>(bar<int>);

可以用g ++ - 8编译，我想这是一个g ++ bug。

Answer 2

template<typename RetType, typename... ArgTypes>
void foo0(std::function<RetType(ArgTypes...)> f) {}

修复是：

template<class X>struct tag_t{using type=X;};
template<class X>using block_deduction = typename tag_t<X>::type;

template<typename RetType, typename... ArgTypes>
void foo0(block_deduction_t<std::function<RetType(ArgTypes...)>> f) {}

现在你的foo0<void, int>(bar)编译。

一般的问题是说foo0<void, int> ，你不是说“ RetType是void ， ArgTypes...是int 。你说的是ArgTypes... 以 int 开头 。

std::function<void(int, double)> x;
foo0<void, int>( x )

以上编译好。

...

c ++ 17中的另一种方法是添加另一个重载。

留下这个：

template<typename RetType, typename... ArgTypes>
void foo2(block_deduction_t<std::function<RetType(ArgTypes...)>> f) {}

但添加：

template<typename RetType, typename... ArgTypes, class F>
void foo2(F&& f) {
  return foo2<RetType, ArgTypes...>( std::function{std::forward<F>(f)} );
}
template<int unused, class F>
void foo2(F&& f) {
  return foo2( std::function{std::forward<F>(f)} );
}

这里我们将F包装成一个构造引导的std::function 。

你对foo2<int, void>( bar )调用现在调用foo2<void, int, decltype(bar)&> ，第二个重载。 然后它继续从它构造一个std::function ，只要签名完全匹配就可以了。