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

Question

据我了解，

std::bind 完美转发它包装的可调用对象和该可调用对象的参数；
std::bind return 对象本身是可移动的 and/or 可复制的，这取决于可调用对象及其参数是否可移动 and/or 可复制；
a std::bind return 对象可以嵌套，在这种情况下，外部 std::bind return 对象是可移动的 and/or 可复制的，就像绑定时一样其他可调用对象。

因此，我希望下面的代码片段可以正常编译。相反，代码在 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，在 do_something() 中调用 f() 时：

(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？

具体来说，我怎样才能

绑定可调用对象？和
将 std::bind return 对象传递给采用通用引用的函数？和
将 std::bind return 对象嵌套在另一个 std::bind?

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

编辑： 澄清一下，我想按值而不是按引用传递包装的可调用对象及其参数，因此 std::ref 无济于事——在至少，不是一个完整的解决方案。原因是我的实际代码更复杂，涉及跨线程边界传递 f std::bind return 对象，a 和 b std::bind return 对象可能在 call_handler 调用 f() 之前超出原始线程的范围，因此 a 和 b 需要复制或移入f，不能仅供参考。也就是说，我的问题具体是关于 std::bind 和完美转发，为了提出一个好问题，我已经提炼出重现我提到的特定编译器错误不需要的所有内容。

Answer 1

您的假设 1 是错误的，bind 总是将绑定参数作为左值传递给它正在包装的可调用对象。为了证明这一点，将 do_something 中的 bind 表达式更改为以下

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

下面这行将编译失败

do_something(std::move(a));

因为 decltype(handler) 是一个右值引用，但是 bind 将尝试使用对您在 main 中传递给它的绑定 lambda 表达式的左值引用来调用 call_handler。

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

Boost 提供 boost::protect，它可以让您屏蔽嵌套 bind 的真实类型，从而防止外部 bind.

对其求值

很遗憾，没有std::protect equivalent, but it's not difficult to write it yourself。

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));
}

只需用 protect 包裹你的内部 bind 表达式，你的代码就会编译。

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

Live demo

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

How to pass std::bind as universal reference type?

c++

stdbind

perfect-forwarding

c++11

c++14