C++ 创建一个通用 std::bind 的 std::packaged_task

Question

我只是尝试为给定的std::bind 创建一个std::packaged_task。

#include <functional>
#include <future>

class A
{
public:
  template<class T>
  void execute(T func)
  {
    std::packaged_task<T> task(func);
  }
};

int main()
{
  auto func = std::bind([](int x) { return x*x; }, 5);

  A name;

  name.execute(func);
}

main.cpp: 在 'void A::execute(T) [with T = std::_Bind(int)>]': main.cpp:20:20: 必需 从这里 main.cpp:10:36: 错误： 'std::packaged_task(int)>> 任务'有 不完全类型 std::packaged_task task(func);

我正在使用 G++ 5.2.0 和 C++14。

有人有想法吗？

谢谢，

Answer 1

从 c++11 开始，不能将函数参数声明为 auto（我相信它是 c++17 的一部分）。不幸的是，我没有支持该功能的编译器，我不太确定它的语义，但解决方法是使用模板：

#include <future>
#include <functional>

template<class T>
void execute(std::function<T> func) // is a std::bind
{
    std::packaged_task<T> task(func);
    //...
}

你可以这样使用：

std::function<int()> func = std::bind([](int x) { return x*x; }, 5);
execute(func);

您收到此错误的问题是std::packaged_task 仅专用于ReturnType(Args...) 形式的模板参数。因此，如果您传递不同的内容，例如从 std::bind 返回的 std::_Binder 或 std::function，它将显示为未定义。

编辑

关于您关于推断 std::function 类型的评论：

您可以使用 lambda，而不是使用 std::bind()。

如果你有一个类 A 与函数 doSomething(int x) 就像你的评论：

class A
{
public:
    int doSomething(int x)
    {
        return x *x;
    }
};

我们需要把execute函数改成如下（见Yakk的回答）：

template<class F, class...Args>
void execute(F&& func, Args&&...args)
{
    using zF = std::decay_t<F>&&;
    using R = std::result_of_t< zF(Args...) >;
    std::packaged_task<R()> task(
        std::bind([func = std::forward<F>(func)](auto&&...args)mutable->R{
        return std::move(func)(decltype(args)(args)...);
    }, std::forward<Args>(args)...)
        );
}

现在你可以这样使用它了：

A a;

auto f = [](A& inst, int x) {  return inst.doSomething(x); };
execute(f, a, 5);

// or

auto g = [&]() { return a.doSomething(5); };
execute(g);

注意

请注意 a 的生命周期，因为 packaged_task 可能会异步运行。

Answer 2

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

template<class...Args, class F>
void execute(F&& func)
{
  using R = std::result_of_t< std::decay_t<F>(Args...) >;
  std::packaged_task<R(Args...)> task(std::forward<F>(func));
}

我添加了完美转发，以及传入参数的选项。如果您不传入参数，则假定传入的可调用对象接受 0 个参数。

使用示例：

auto func = std::bind([](int x) { return x*x; }, 5);
A name;
name.execute(func);

如果func 需要参数，则必须显式传递它们。这是公平的，因为在不知道它会期望什么参数的情况下很难使用std::packaged_task。 ;)

这也可以编译：

auto func = [](int x) { return x*x; };
A name;
name.execute<int>(func);

但是你将如何使用打包的任务是很棘手的。

如果你想模仿std::async之类的接口，我们可以这样做：

template<class F, class...Args>
void execute(F&& func, Args&&...args)
{
  using zF = std::decay_t<F>&&;
  using R = std::result_of_t< zF(Args...) >;
  std::packaged_task<R()> task(
    std::bind( [func=std::forward<F>(func)](auto&&...args)mutable->R{
      return std::move(func)(decltype(args)(args)...);
    }, std::forward<Args>(args)... )
  );
}

它小心地将传入的func 包装在一个lambda 中，以避免在bind 上调用bind，然后绑定传入的参数。

现在你可以：

name.execute([](int x){ return x*x; }, 5);

完全不使用bind。

上面的代码没有编译，可能包含tpyos。