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中得到了纳瓦兹答复的答案。

我从他的回答中粘贴了副本：

    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的模板参数无关。 < / p>

Answer 1

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

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

template<class F> function(F f);

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

C ++ 14标准确实约束了模板（因为LWG DR 2132）所以它：

除非f对于参数类型ArgTypes...是可调用的（20.9.12.2）并且返回类型R，否则
不应参与重载决策。

这意味着当Functor与std::function（在您的示例中为void(int, int)）的调用签名兼容时，编译器将仅允许调用构造函数。理论上，这应该意味着void add(A, A)不是一个可行的论据，所以“显然”你打算使用void add(int, int)。

但是，编译器无法测试“f是否可以调用参数类型...”约束，直到它知道f的类型，这意味着它需要在void add(int, int)和void add(A, A) 之间消除歧义之前它可以应用允许它拒绝其中一个函数的约束！

所以有鸡和蛋的情况，遗憾的是你需要通过准确指定你想要使用的add的哪个重载来帮助编译器，然后然后编译器可以应用约束并（相当冗余地）确定它是构造函数的可接受参数。

可以想象我们可以改变C ++，以便在像 all 这样的情况下，根据约束测试重载函数（因此我们在测试之前不需要知道要测试哪一个）如果只有一个是可行的，那么使用那个，但这不是C ++的工作原理。

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

尝试：

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

地址为void add(A, A)和void add(int, int) obvoiusly差异。当你通过名字指向函数时，编译器知道你需要哪个函数地址几乎是不可能的。 void(int, int)这里没有提示。

Answer 4

另一种解决这个问题的方法是使用C ++ 14中的通用lambda：

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

这将创建一个lambda函数，可以解决问题而不会产生歧义。我没有提出论点，

Answer 5

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

c ++ 11 standard（20.8.11）

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

但VisualStudio没有专业化

clang ++和g ++完全没有重载std :: functions

之前的答案解释了为什么VS不起作用，但他们没有提到它的VS＆＃39;错误

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

5 个答案: