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

Question

据我了解

1. std::bind 完美地将其包装的可调用对象和参数转发给该可调用对象；
2. std::bind 返回对象本身是可移动和/或可复制的，具体取决于可调用对象及其参数是否可移动和/或可复制；
3. std::bind 返回对象可以嵌套，在这种情况下，外部std::bind 返回对象是可移动和/或可复制的，就像绑定其他可调用对象时一样。

因此，我希望下面的代码 sn-p 可以编译好。相反，代码会在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了吗？

具体怎么做

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

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

编辑：为了澄清，我想通过值而不是通过引用传递包装的可调用对象及其参数，因此std::ref 将无济于事 - 至少，不是完整的解决方案.原因是我的真实代码更复杂，涉及通过线程边界传递fstd::bind返回对象，并且a和bstd::bind返回对象都可能超出原始范围在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 会尝试调用call_handler，并使用对您在main 中传递的绑定lambda 表达式的左值引用。

---

现在，您的示例后半部分出了什么问题。 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