std::function 无法区分重载函数

Question

我想了解为什么 std::function 无法区分重载函数。

#include <functional>

void add(int,int){}

class A {};

void add (A, A){}

int main(){
        std::function <void(int, int)> func = add;
}

在上面显示的代码中，function<void(int, int)> 只能匹配其中一个函数，但它失败了。为什么会这样？我知道我可以通过使用 lambda 或指向实际函数的函数指针然后将函数指针存储在函数中来解决这个问题。但是为什么会失败呢？我想被选中的功能的上下文不是很清楚吗？请帮助我理解为什么会失败，因为我无法理解为什么在这种情况下模板匹配会失败。

我在 clang 上得到的编译器错误如下：

test.cpp:10:33: error: no viable conversion from '<overloaded function type>' to
      'std::function<void (int, int)>'
        std::function <void(int, int)> func = add;
                                       ^      ~~~
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/__functional_03:1266:31: note: 
      candidate constructor not viable: no overload of 'add' matching
      'std::__1::nullptr_t' for 1st argument
    _LIBCPP_INLINE_VISIBILITY function(nullptr_t) : __f_(0) {}
                              ^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/__functional_03:1267:5: note: 
      candidate constructor not viable: no overload of 'add' matching 'const
      std::__1::function<void (int, int)> &' for 1st argument
    function(const function&);
    ^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/__functional_03:1269:7: note: 
      candidate template ignored: couldn't infer template argument '_Fp'
      function(_Fp,
      ^
1 error generated.

编辑 - 除了 MSalters 的回答之外，我还在这个论坛上进行了一些搜索，找到了失败的确切原因。我在这个 post.

中从 Nawaz 的回复中得到了答案

我从他的回答中复制粘贴了这里：

    int test(const std::string&) {
        return 0;
    }

    int test(const std::string*) {
        return 0;
    }

    typedef int (*funtype)(const std::string&);

    funtype fun = test; //no cast required now!
    std::function<int(const std::string&)> func = fun; //no cast!

那么为什么 std::function<int(const std::string&)> 不像上面 funtype fun = test 那样工作？

答案是，因为 std::function 可以用任何对象初始化，因为它的构造函数是模板化的，它独立于您传递给 std::function 的模板参数。

Answer 1

尝试：

std::function <void(int, int)> func = static_cast<void(*)(int, int)> (add);

void add(A, A) 和 void add(int, int) 的地址明显不同。当您按名称指向函数时，编译器几乎不可能知道您需要哪个函数地址。 void(int, int)这里就不提示了

Answer 2

虽然你想要什么很明显，但问题是 std::function 不能影响 &add 的重载解析。如果您要初始化原始函数指针 (void (*func)(int,int) = &add)，它确实有效。那是因为函数指针初始化是完成重载决议的上下文。目标类型是确切已知的。但是 std::function 几乎可以接受任何可调用的参数。接受参数的这种灵活性确实意味着您不能对 &add 进行重载解析。 add 的多个重载可能是合适的。

显式转换会起作用，即 static_cast<void(*)(int, int)> (&add)。

这可以包含在 template<typename F> std::function<F> make_function(F*) 中，这样您就可以编写 auto func = make_function<int(int,int)> (&add)

Answer 3

我们很清楚你打算选择哪个函数，但编译器必须遵循 C++ 的规则，不要使用巧妙的逻辑跳跃（甚至不是那么聪明的逻辑跳跃，就像在这样的简单情况下！）

std::function的相关构造函数是：

template<class F> function(F f);

这是一个接受任何类型的模板。

C++14 标准确实限制了模板（因为 LWG DR 2132），因此它：

shall not participate in overload resolution unless f is Callable (20.9.12.2) for argument types ArgTypes... and return type R.

这意味着编译器只允许在 Functor 与 std::function 的调用签名兼容时调用构造函数（在您的示例中为 void(int, int) ）。从理论上讲，这应该意味着 void add(A, A) 不是一个可行的论点，因此 "obviously" 您打算使用 void add(int, int).

但是，编译器无法测试“f is Callable for argument types ...”约束，直到它知道 [=12= 的类型]，这意味着它需要在 void add(int, int) 和 void add(A, A) 之间消除歧义，然后才能应用允许它拒绝其中一个函数的约束！

所以这是先有鸡还是先有蛋的情况，不幸的是，这意味着您需要通过准确指定要使用 add 的哪个重载来帮助编译器，然后 then 编译器可以应用约束并（相当冗余地）决定它是构造函数可接受的参数。

可以想象，我们可以更改 C++，以便在这种情况下所有重载函数都针对约束进行测试（因此我们不需要知道要对哪一个进行测试）在测试之前先测试），如果只有一个可行，则使用那个，但这不是 C++ 的工作方式。

Answer 4

据我所知，这是一个 Visual Studio 问题。

c++11 标准 (20.8.11)

std::function synopsis
template<class R, class... ArgTypes> class function<R(ArgTypes...)>;

但 VisualStudio 没有那种专业化

clang++ 和 g++ 完全可以重载 std::functions

之前的答案解释了为什么 VS 不起作用，但他们没有提到这是 VS 的错误

Answer 5

另一种处理此问题的方法是使用 C++14 中的通用 lambda：

int main() {
    std::function <void(int, int)> func = [](auto &&... args) { add(std::forward<decltype(args)>(args)...);
}

这将创建一个 lambda 函数，它将毫无歧义地解决问题。我没有转发论据，

std::function 无法区分重载函数

std::function fails to distinguish overloaded functions

c++

overload-resolution

c++11

std-function