c++ - std::bind 绑定(bind)函数

Question

我在检测为什么这不编译时遇到了麻烦。我有一些 lambda 函数，它根据一些参数返回一个 std::function 。

我已将我的问题缩小到这个片段(它不使用 lambda，但完美地重现了我的错误):

#include <functional>
#include <iostream>


struct foo {
    template<class T>
    void bar(T data) {
        std::cout << data << "\n";
    }
};

void some_fun(const std::function<void(int)> &f) {
    f(12);
}

int main() {
    foo x;
    auto f = std::bind(&foo::bar<int>, x, std::placeholders::_1);
    auto w = std::bind(some_fun, f);
    w();
}

对 w() 的调用会产生一个可爱的 gcc 错误输出，其中我无法弄清楚出了什么问题。这是 gcc 4.6.1 回显的错误:

g++ -std=c++0x    test.cpp   -o test
test.cpp: In function ‘int main()’:
test.cpp:20:7: error: no match for call to ‘(std::_Bind<void (*(std::_Bind<std::_Mem_fn<void (foo::*)(int)>(foo, std::_Placeholder<1>)>))(const std::function<void(int)>&)>) ()’
/usr/include/c++/4.6/functional:1130:11: note: candidates are:
/usr/include/c++/4.6/functional:1201:2: note: template<class ... _Args, class _Result> _Result std::_Bind<_Functor(_Bound_args ...)>::operator()(_Args&& ...) [with _Args = {_Args ...}, _Result = _Result, _Functor = void (*)(const std::function<void(int)>&), _Bound_args = {std::_Bind<std::_Mem_fn<void (foo::*)(int)>(foo, std::_Placeholder<1>)>}]
/usr/include/c++/4.6/functional:1215:2: note: template<class ... _Args, class _Result> _Result std::_Bind<_Functor(_Bound_args ...)>::operator()(_Args&& ...) const [with _Args = {_Args ...}, _Result = _Result, _Functor = void (*)(const std::function<void(int)>&), _Bound_args = {std::_Bind<std::_Mem_fn<void (foo::*)(int)>(foo, std::_Placeholder<1>)>}]
/usr/include/c++/4.6/functional:1229:2: note: template<class ... _Args, class _Result> _Result std::_Bind<_Functor(_Bound_args ...)>::operator()(_Args&& ...) volatile [with _Args = {_Args ...}, _Result = _Result, _Functor = void (*)(const std::function<void(int)>&), _Bound_args = {std::_Bind<std::_Mem_fn<void (foo::*)(int)>(foo, std::_Placeholder<1>)>}]
/usr/include/c++/4.6/functional:1243:2: note: template<class ... _Args, class _Result> _Result std::_Bind<_Functor(_Bound_args ...)>::operator()(_Args&& ...) const volatile [with _Args = {_Args ...}, _Result = _Result, _Functor = void (*)(const std::function<void(int)>&), _Bound_args = {std::_Bind<std::_Mem_fn<void (foo::*)(int)>(foo, std::_Placeholder<1>)>}]

这里，f 应该是一些可调用对象，它以 int 作为参数并使用它调用 x.bar(int)。另一方面，w只是一个调用some_fun(f)的可调用对象，也就是f上面提到的可调用对象，它有some_fun 的参数所期望的签名。

我错过了什么吗？我可能不知道如何真正混合 std::bind 和 std::function。

Answer 1

std::bind 表达式，比如他们的 boost::bind前辈，支持一种组合操作。您对 w 的表达大致相当于

auto w=std::bind(some_fun,  std::bind(&foo::bar<int>, x, std::placeholders::_1) );

以这种方式嵌套绑定(bind)被解释为

1. 计算 x.bar<int>(y) 的值在哪里 y是传递给结果仿函数的第一个参数。
2. 将结果传递给 some_fun .

但是x.bar<int>(y)返回 void，而不是任何函数类型。这就是为什么它不能编译。

正如 K-ballo 指出的，与 boost::bind ，您可以使用 boost::protect 解决此问题.正如 Kerrek SB 和 ildjarn 指出的那样，解决此问题的一种方法是:不要使用 auto对于 f .你不想要f具有绑定(bind)表达式的类型。如果 f有一些其他类型，然后 std::bind不会尝试应用函数组合规则。例如，您可以给出 f类型 std::function<void(int)> :

std::function<void(int)> f = std::bind(&foo::bar<int>, x, std::placeholders::_1);
auto w = std::bind(some_fun, f);

自从 f字面上没有绑定(bind)表达式的类型，std::is_bind_expression<>::value将在 f 上为假的类型，所以 std::bind第二行中的表达式只会逐字传递值，而不是尝试应用函数组合规则。