如何使对模板函数的调用不那么冗长

Question

有一个功能

template <class ...T>
void foo(std::function<void(T...)> callback);

我将回调传递到其中。

我想做类似的事情

foo(bar);

例如，bar 在哪里

void bar(int a, long b, double c, float d);

但这给了我

error: no matching function for call to bar(void (&)(int, long int, double, float))

我必须打电话给foo

foo(std::function<void(int, long, double, float)>(bar));

这太冗长了。甚至

foo<int, long, double, float>(bar);

会更好。

foo(bar);

会很理想。

无论如何，我怎样才能让foo 的调用不那么冗长？

编辑：foo 的声明必须保持不变。

Answer 1

我会编写一个包装器函数，将函数指针转换为std::function 包装器：

template <typename... T>
void foo(std::function<void (T...)> f) {}

template <typename... T>
void foo(void (*f)(T...)) {
    foo(std::function<void (T...)>(f));
}

foo() 可以任意调用：

void bar(int,double) {}

void foo_caller() {
    foo(std::function<void (int,double)>(bar));
    foo(bar);
}

附录：非静态成员函数包装器

同样的方法可以用于指向成员的函数——只需添加另一个重载：

template <typename C,typename... T>
void foo(void (C::*f)(T...)) {
    foo(std::function<void (C *,T...)>(f));
}

注意成员函数的this 指针的额外第一个参数。用法类似：

struct quux {
    void mf(char *,double) {}
};

void foo_caller() {
    foo(&quux::mf);
}

Answer 2

如果你知道你会将一个普通的函数指针传递给foo，而不仅仅是任何C++11 lambda，你可以将foo重新定义为：

template <class ...T>
void foo(void(*callback)(T...)) {
   // .....
}

如果你想支持 lambdas，你可以更通用的类型

template <class LambdaType>
void foo(LambdaType callback) {
   // .....
}

这种方法的缺点是，如果您传递的不是函数或 lambda，您将收到来自 foo 内部的奇怪模板错误消息。

---

使用您的原始解决方案，编译器在将T... 与int, long, double, float 匹配时出现问题，可能是因为它是嵌套类型。

如果我告诉你将void(int, double) 匹配到MyTempalte<T...>，你不会知道我打算用int, double 替换T...，因为你不知道MyTemplate 对其参数做了什么。也许MyTemplate 首先对其模板参数做了一些奇怪的事情？

同样，编译器不知道如何将std::function 模板参数匹配到您的函数指针。

Answer 3

如果您的foo 定义不是一成不变的，可以将其更改为

#include <functional>

template <class Ret, class ...T>
void foo(Ret callback(T... params))
{
}

void bar(int a, long b, double c, float d){}

int main() 
{
    foo(bar);
}