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

Question

据我了解，

1. std::bind完美地转发它包装的可调用对象和该可调用对象的参数；
2. std::bind返回对象本身是可移动和/或可复制的，具体取决于可调用对象及其参数是否可移动和/或可复制；
3. 一个std::bind返回对象可能是嵌套的，在这种情况下，外部 std::bind返回对象是可移动和/或可复制的，就像绑定(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() 时在 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. 绑定(bind)一个可调用对象？和
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 中的 bind 表达式更改为以下内容

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

下面这行将无法编译

do_something(std::move(a));

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

---

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

Boost 提供 boost::protect这使您可以屏蔽嵌套 bind 的真实类型，从而防止外部 bind 对其进行评估。

很遗憾，没有 std::protect等效，但不难 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