在模板化函数中推断函数重载

Question

我正在编写我自己的 std::async 模拟（必须回到 Intel13/gcc 4.4 STL），这工作正常：

template <typename Func, typename ...Args>
struct return_value {
    template <typename T>
    using decayed = typename std::decay<T>::type;
    using type    = typename std::result_of<decayed<Func>(decayed<Args>...)>::type;
};

template <typename Func, typename ...Args>
typename return_value<Func,Args...>::type async(Func &&func, Args&&... args) {
    return func(args...);
}

void run(int a, double b) { 
    printf("a: %i  b: %f\n", a, b);
}

int main() {
    async(run, 1, 3.14);
}

但如果我为run 添加重载：

void run() {
    printf("no args\n");
}

那就不能正常解决：

<source>: In function 'int main()':
<source>:27:23: error: no matching function for call to 'async(<unresolved overloaded function type>, int, double)'
     async(run, 1, 3.14);
                       ^
<source>:14:43: note: candidate: 'template<class Func, class ... Args> typename return_value<Func, Args>::type async(Func&&, Args&& ...)'
 typename return_value<Func,Args...>::type async(Func &&func, Args&&... args) {
                                           ^~~~~
<source>:14:43: note:   template argument deduction/substitution failed:
<source>:27:23: note:   couldn't deduce template parameter 'Func'
     async(run, 1, 3.14);
                       ^
Compiler returned: 1

如何将函数作为模板参数并正确推断给定参数的重载？

Answer 1

除非您知道返回类型，否则我个人看不到消除重载歧义的方法。您可以假设返回类型 void 最常见，然后：（为简洁起见，我正在简化您的示例）

template <class F, class... Args>
auto async(F f, Args... args)
{
    return f(args...);
}

template <class... Args>
auto async(void (*f)(Args...), Args... args)
{
    return f(args...);
}

void run();
void run(int, double);

auto test()
{
    async(run); // calls run();
    async(run, 1, 2.); // calls run(int, double);
}

这对用户来说似乎有点可疑和困惑。为什么当传递的函数返回void 时它会起作用，而如果它返回int 则不起作用？所以不推荐。

所以实际上你唯一能做的就是让用户自己去解决它。

所以你的函数调用者的一些解决方案：

好的（和丑陋的）旧方法：使用强制转换消除重载的歧义：

async(static_cast<int(*)(int, double)>(run), 1, 2.);

我个人完全不喜欢这种方法。我不喜欢它的冗长，最重要的是我不喜欢我必须明确表达一些真正应该是隐含的东西。

lambda 方式

async([] { return run(1, 2.); });

我喜欢这个。这还不错。仍然有点冗长，但比其他替代方案要好得多。

宏方式

是的，宏，在 C++ 中。事不宜迟，就是这样（为简洁起见，省略了完美的转发）：

#define OVERLOAD(foo) [] (auto... args) { return foo(args...); }

async(OVERLOAD(run), 1, 2.);

我不会对此发表评论。我让你们每个人来判断这个宏。