如何将std :: bind作为通用引用类型传递？

Question

据我了解,

1. std::bind 完美地转发它包装的可调用对象和该可调用对象的参数;
2. 该std::bind返回对象本身是可移动的和/或能够复制,这取决于可调用对象和其参数是否是可移动的和/或能够复制;
3. 一个std::bind返回对象可以是嵌套的,在这种情况下,外部std::bind返回对象是可移动的和/或能够复制,正如结合其他可调用的对象时.

因此,我希望以下代码片段可以编译好.相反,代码会在最后两个语句中生成一堆编译器错误main().

#include <functional>

template<typename HandlerType>
void call_handler(HandlerType&& handler)
{
  handler();
}

template<typename HandlerType>
void do_something(HandlerType&& handler)
{
  auto f = std::bind(
    &call_handler<HandlerType&>,
    std::forward<HandlerType>(handler));
  f();
}

int main()
{
  auto a = [&]() {};
  do_something(a);
  do_something(std::move(a));

  auto b = std::bind([&]() {});
  do_something(b);              // <- compiler error!
  do_something(std::move(b));   // <- compiler error!
}

两个问题行中的每一个都没有出现另一个错误.为了消除所有错误,我必须注释掉这两行.

这是一个示例错误,来自Cygwin中的g ++ 4.9.2,在调用f()in do_something():

(4 of 103): error: no match for call to ‘(std::_Bind<void (*(std::_Bind<main()::<lambda()>()>))(std::_Bind<main()::<lambda()>()>&)>) ()’

以下是Visual Studio 2013中的示例错误,位于同一行:

1>C:\Program Files (x86)\Microsoft Visual Studio12.0\VC\include\functional(1149): error C2664: 'void (HandlerType)' : cannot convert argument 1 from 'void' to 'std::_Bind<false,void,main::<lambda_2b8ed726b4f655ffe5747e5b66152230>,> '

这是怎么回事？我误解了std::bind吗？

具体来说,我怎么能

1. 绑定可调用对象？和
2. 将该std::bind返回对象传递给采用通用引用的函数？和
3. std::bind在另一个中返回对象的嵌套std::bind？

我的目标是将底层可调用对象及其参数完美转发.

编辑:为了澄清,我想通过值传递包装的可调用对象及其参数,而不是通过引用传递,所以std::ref不会帮助 - 至少,不是完整的解决方案.其原因是,我真正的代码更加复杂,包括使f std::bind返回的对象跨线程边界,以及两个a与b std::bind返回的对象可能超出范围在之前的原始线程call_handler调用f(),所以a和b需要复制或移动到f,不仅仅是参考.也就是说,我的问题是关于std::bind并完美转发,为了提出一个好问题,我已经提炼出了所有不需要的东西来重现我提到的特定编译器错误.

Answer 1

你的假设1是错误的,bind总是将绑定的参数作为左值传递给它正在包装的可调用对象.要演示这一点,请将bind表达式更改do_something为以下内容

auto f = std::bind(
    &call_handler<decltype(handler)>,
    std::forward<HandlerType>(handler));

然后,以下行将无法编译

do_something(std::move(a));

因为decltype(handler)是一个右值引用,但是bind会尝试call_handler使用左值引用调用你传入它的绑定lambda表达式main.

现在你的例子的后半部分出了什么问题.bind对嵌套bind表达式有特殊处理,它将识别和评估.但是,在您的示例中,您不希望发生这种情况.相反,您希望嵌套bind按原样转发call_handler,然后将调用它.

Boost提供了boost::protect允许您屏蔽嵌套的真实类型,bind从而阻止其由外部评估bind.

不幸的是,没有std::protect相应的东西,但是自己写它并不困难.

template<typename T>
struct protect_wrapper : T
{
    protect_wrapper(const T& t) : T(t)
    {}

    protect_wrapper(T&& t) : T(std::move(t))
    {}
};

template<typename T>
std::enable_if_t<!std::is_bind_expression<std::decay_t<T>>::value,
                 T&&
                >
protect(T&& t)
{
    return std::forward<T>(t);
}

template<typename T>
std::enable_if_t<std::is_bind_expression<std::decay_t<T>>::value,
                 protect_wrapper<std::decay_t<T>>
                >
protect(T&& t)
{
    return protect_wrapper<std::decay_t<T>>(std::forward<T>(t));
}

只需用你的内部bind表达式包装protect,你的代码就会编译.

auto b = protect(std::bind([&]() {}));
do_something(b);
do_something(std::move(b));

现场演示