Question

据我所知，

std::bind完美地转发它包装的可调用对象和该可调用对象的参数;
std::bind返回对象本身是可移动的和/或可复制的，具体取决于可调用对象及其参数是否可移动和/或可复制;
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()中的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？

具体来说，我怎么能

绑定一个可调用对象？和
将std::bind返回对象传递给采用通用引用的函数？和
嵌套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等价物，但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));
}

用bind包裹内部protect表达式，然后编译代码。

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

Live demo

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

1 个答案: