通过 std::bind 传递右值

Question

我想通过 std::bind 将右值传递给在 C++0x 中采用右值引用的函数。我不知道该怎么做。例如：

#include <utility>
#include <functional>

template<class Type>
void foo(Type &&value)
{
    Type new_object = std::forward<Type>(value);    // move-construct if possible
}

class Movable
{
public:
    Movable(Movable &&) = default;
    Movable &operator=(Movable &&) = default;
};

int main()
{
    auto f = std::bind(foo<Movable>, Movable());
    f();    // error, but want the same effect as foo(Movable())
}

Answer 1

失败的原因是，当您指定 foo 时，您要绑定的函数是：

void foo(Movable&&) // *must* be an rvalue
{
}

但是，std::bind 传递的值将不会是一个右值，但是一个左值（作为成员存储在生成的 bind 函子中的某个位置）。也就是说，生成的函子类似于：

struct your_bind
{
    your_bind(Movable arg0) :
    arg0(arg0)
    {}

    void operator()()
    {
        foo<int>(arg0); // lvalue!
    }

    Movable arg0;
};

构造为 your_bind(Movable())。因此，您可以看到此操作失败，因为 Movable&& 无法绑定到 Movable。†

一个简单的解决方案可能是这样的：

auto f = std::bind(foo<Movable&>, Movable());

因为现在您调用的函数是：

void foo(Movable& /* conceptually, this was Movable& &&
                        and collapsed to Movable& */)
{
}

并且调用工作正常（当然，如果需要，您可以使 foo）。但一个有趣的问题是，我们是否可以让您的原始绑定起作用，我们可以通过：

auto f = std::bind(foo<Movable>,
            std::bind(static_cast<Movable&&(&)(Movable&)>(std::move<Movable&>),
                Movable()));

也就是说，我们只需在调用之前 std::move 参数，以便它可以绑定。但哎呀，这太丑了。强制转换是必需的，因为 std::move 是一个重载函数，因此我们必须通过强制转换为所需类型来指定我们想要的重载，从而消除其他选项。

如果 std::move 没有重载，实际上不会那么糟糕，就好像我们有这样的东西：

Movable&& my_special_move(Movable& x)
{
    return std::move(x);
}


auto f = std::bind(foo<Movable>, std::bind(my_special_move, Movable()));

这更简单。但除非您有这样的函数，否则我认为很明显您可能只是想指定一个更明确的模板参数。

---

† 这与在没有显式模板参数的情况下调用函数不同，因为显式指定它消除了推断它的可能性。 （T&&，其中 T 是模板参数，可以推导出任何东西，如果你愿意的话。）

Answer 2

您可以使用 lambda 表达式。

auto f = [](){ foo(Movable()); };

这似乎是最简单的选择。

Answer 3

伙计们，我在这里编写了一个完美转发版本的活页夹（仅限 1 个参数）
http://code-slim-jim .blogspot.jp/2012/11/stdbind-not-compatable-with-stdmove.html

供参考，代码是

template <typename P>
class MovableBinder1
{
  typedef void (*F)(P&&);

private:
  F func_;
  P p0_;

public:
  MovableBinder1(F func, P&& p) :
    func_(func),
    p0_(std::forward<P>(p))
  {
    std::cout << "Moved" << p0_ << "\n";
  }

  MovableBinder1(F func, P& p) :
    func_(func),
    p0_(p)
  {
    std::cout << "Copied" << p0_ << "\n";
  }

  ~MovableBinder1()
  {
    std::cout << "~MovableBinder1\n";
  }

  void operator()()
  {
    (*func_)(std::forward<P>(p0_));
  }
};

正如您从上面的概念证明中看到的那样，它很有可能......

我看不出任何原因为什么 std::bind 与 std::move 不兼容... std::forward 毕竟是完美转发的我不明白为什么没有 std::forwarding_bind ???

Answer 4

（这实际上是对 GMan 答案的评论，但我需要对代码进行一些格式化）。
如果生成的函子实际上是这样的：

struct your_bind
{
    your_bind(Movable arg0) :
    arg0(arg0)
    {}

    void operator()()
    {
        foo(arg0);
    }

    Movable arg0;
};

则

int main()
{
    auto f = your_bind(Movable());
    f();    // No errors!
}

编译无错误。因为可以使用右值分配和初始化数据，然后将数据值传递给 foo() 的右值参数。
但是，我认为绑定实现直接从 foo() 签名中提取函数参数类型。即生成的函子是：

struct your_bind
{
    your_bind(Movable && arg0) :
    arg0(arg0) // ****  Error:cannot convert from Movable to Movable &&
    {}

    void operator()()
    {
        foo(arg0); 
    }

    Movable&& arg0;
};

事实上，这确实无法初始化右值数据成员。
也许，绑定实现只是没有正确地从函数参数类型中提取“未引用”类型，并“按原样”使用该类型作为函子的数据成员声明，​​而不修剪 &&。

正确的函子应该是：

struct your_bind
{
    your_bind(Movable&& arg0) :
    arg0(arg0)
    {}

    void operator()()
    {
        foo(arg0); 
    }

    Movable arg0; // trim && !!!
};

Answer 5

GManNickG 的答案还有一项改进，我得到了很好的解决方案：（

auto f = std::bind(
    foo<Movable>,
    std::bind(std::move<Movable&>, Movable())
);

适用于 gcc-4.9.2 和 msvc2013）