std::function 的模板参数（签名）不是其类型的一部分吗？

Question

鉴于以下代码，歧义背后的原因是什么？我可以绕过它还是必须保留（烦人的）显式强制转换？

#include <functional>

using namespace std;

int a(const function<int ()>& f)
{
    return f();
}

int a(const function<int (int)>& f)
{
    return f(0);
}

int x() { return 22; }

int y(int) { return 44; }

int main()
{
    a(x);  // Call is ambiguous.
    a(y);  // Call is ambiguous.

    a((function<int ()>)x);    // Works.
    a((function<int (int)>)y); // Works.

    return 0;
}

有趣的是，如果我使用 function 参数注释掉 a() 函数，并在我的main 中，由于 x 与唯一 a() 的参数 function 之间的类型不匹配，编译正确失败> 功能可用。如果编译器在这种情况下失败，为什么当两个 a() 函数存在时会出现歧义？

我尝试过 VS2010 和 g++ v.4.5。两者都给了我完全相同的模糊性。

Answer 1

问题是 function 和 function 都可以从同一个函数构造。这就是 VS2010 中 std::function 的构造函数声明的样子：

template<class _Fx>
function(_Fx _Func, typename _Not_integral<!_Is_integral<_Fx>::value, int>::_Type = 0);

忽略 SFINAE 部分，它几乎可以由任何内容构造。
std::/boost::function 采用一种称为类型擦除的技术，允许传入任意对象/函数，只要它们在调用时满足签名即可。这样做的一个缺点是，当提供一个无法像签名希望的那样被调用的对象时，您会在实现的最深处（正在调用保存的函数）而不是在构造函数中遇到错误。

---

这个问题可以用这个小类来说明：

template<class Signature>
class myfunc{
public:
    template<class Func>
    myfunc(Func a_func){
        // ...
    }
};

现在，当编译器搜索重载集的有效函数时，如果不存在完美的拟合函数，它会尝试转换参数。转换可以通过函数参数的构造函数进行，也可以通过提供给函数的参数的转换运算符进行。在我们的例子中，是前者。
编译器尝试第一次重载a。为了使其可行，需要进行转换。要将 int(*)() 转换为 myfunc，它会尝试 myfunc 的构造函数。作为一个可以接受任何东西的模板，转换自然会成功。
现在它尝试对第二次过载进行相同的操作。构造函数仍然相同，并且仍然接受给定的任何内容，转换也有效。
由于重载集中只剩下 2 个函数，编译器就像一只悲伤的熊猫，不知道该怎么做，所以它只是说调用是不明确的。

---

所以最后，模板的 Signature 部分在进行声明/定义时确实属于该类型，但在您想要构造对象时则不属于该类型。

---

编辑：
我全神贯注于回答标题问题，完全忘记了你的第二个问题。 :(

我可以绕过它还是必须保留（烦人的）显式强制转换？

Afaik，你有 3 个选择。

• 保持强制转换

• 创建适当类型的函数对象并传递该对象

  函数fx = x；
函数fy = y；
a(fx)；
a(fy);

• 隐藏函数中繁琐的转换并使用 TMP 获取正确的签名

TMP（模板元编程）版本非常冗长并且带有样板代码，但它向客户端隐藏了转换。可以在此处找到示例版本，该版本依赖于部分专用的get_signature元函数关于函数指针类型（并提供了一个很好的例子，模式匹配如何在 C++ 中工作）：

template<class F>
struct get_signature;

template<class R>
struct get_signature<R(*)()>{
  typedef R type();
};

template<class R, class A1>
struct get_signature<R(*)(A1)>{
  typedef R type(A1);
};

当然，这需要扩展您想要支持的参数数量，但这只需完成一次，然后埋在 中“get_signature.h”标头。 :)

我考虑过但立即放弃的另一个选择是 SFINAE，它会引入比 TMP 版本更多的样板代码。

所以，是的，这就是我所知道的选项。希望其中之一适合您。 :)

Answer 2

我已经看到这个问题多次出现了。 libc++ 现在可以毫无歧义地编译此代码（作为一致的扩展）。

逾期更新

事实证明，这个“扩展”非常受欢迎，以至于它在 C++14 中被标准化（尽管我个人并不负责完成这项工作）。

事后看来，我没有完全正确地得到这个扩展。本月早些时候（2015-05-09）委员会对LWG 问题 2420 有效地更改了 Callable 的定义，因此如果 std::function 具有 void 返回类型，它将忽略包装的函子，但如果其他一切都匹配，仍然认为它是可调用的，而不是认为它不是可调用的。

此后 C++14 调整不会影响此特定示例，因为涉及的返回类型始终为 int。

Answer 3

下面是如何将 std::function 包装在一个类中的示例，该类检查其构造函数参数的可调用性：

template<typename> struct check_function;
template<typename R, typename... Args>
struct check_function<R(Args...)>: public std::function<R(Args...)> {
    template<typename T,
        class = typename std::enable_if<
            std::is_same<R, void>::value
            || std::is_convertible<
                decltype(std::declval<T>()(std::declval<Args>()...)),
                R>::value>::type>
        check_function(T &&t): std::function<R(Args...)>(std::forward<T>(t)) { }
};

像这样使用：

int a(check_function<int ()> f) { return f(); }
int a(check_function<int (int)> f) { return f(0); }

int x() { return 22; }
int y(int) { return 44; }

int main() {
    a(x);
    a(y);
}

请注意，这与函数签名上的重载并不完全相同，因为它将可转换参数（和返回）类型视为等效类型。对于精确的重载，这应该有效：

template<typename> struct check_function_exact;
template<typename R, typename... Args>
struct check_function_exact<R(Args...)>: public std::function<R(Args...)> {
    template<typename T,
        class = typename std::enable_if<
            std::is_convertible<T, R(*)(Args...)>::value>::type>
        check_function_exact(T &&t): std::function<R(Args...)>(std::forward<T>(t)) { }
};

Answer 4

std::function 有一个采用任意类型（即除 T 之外的类型）的转换构造函数。当然，在这种情况下，该 ctor 会导致类型不匹配错误，但编译器不会走到这一步——调用是不明确的，仅仅因为该 ctor 存在。