如何将通用 packaged_tasks 存储在容器中？

Question

我正在尝试采用 std::async 样式的 'task' 并将其存储在容器中。我必须克服困难才能实现它，但我认为必须有更好的方法。

std::vector<std::function<void()>> mTasks;

template<class F, class... Args>
std::future<typename std::result_of<typename std::decay<F>::type(typename std::decay<Args>::type...)>::type>
push(F&& f, Args&&... args)
{
    auto func = std::make_shared<std::packaged_task<typename std::result_of<typename std::decay<F>::type(typename std::decay<Args>::type...)>::type()>>(std::bind(std::forward<F>(f), std::forward<Args>(args)...));
    auto future = func->get_future();

    // for some reason I get a compilation error in clang if I get rid of the `=, ` in this capture:
    mTasks.push_back([=, func = std::move(func)]{ (*func)(); });

    return future;
}

所以我正在使用 bind -> packaged_task -> shared_ptr -> lambda -> function。我怎样才能做到这一点 better/more 最佳？如果有一个 std::function 可以执行不可复制但可移动的任务，那肯定会更容易。我可以将 std::forward args 放入 lambda 的捕获中，还是必须使用 bind?

Answer 1

杀无赦。

第 1 步：编写一个 SFINAE 友好 std::result_of 和一个函数来帮助通过元组调用：

namespace details {
  template<size_t...Is, class F, class... Args>
  auto invoke_tuple( std::index_sequence<Is...>, F&& f, std::tuple<Args>&& args)
  {
    return std::forward<F>(f)( std::get<Is>(std::move(args)) );
  }
  // SFINAE friendly result_of:
  template<class Invocation, class=void>
  struct invoke_result {};
  template<class T, class...Args>
  struct invoke_result<T(Args...), decltype( void(std::declval<T>()(std::declval<Args>()...)) ) > {
    using type = decltype( std::declval<T>()(std::declval<Args>()...) );
  };
  template<class Invocation, class=void>
  struct can_invoke:std::false_type{};
  template<class Invocation>
  struct can_invoke<Invocation, decltype(void(std::declval<
    typename invoke_result<Inocation>::type
  >()))>:std::true_type{};
}

template<class F, class... Args>
auto invoke_tuple( F&& f, std::tuple<Args>&& args)
{
  return details::invoke_tuple( std::index_sequence_for<Args...>{}, std::forward<F>(f), std::move(args) );
}

// SFINAE friendly result_of:
template<class Invocation>
struct invoke_result:details::invoke_result<Invocation>{};
template<class Invocation>
using invoke_result_t = typename invoke_result<Invocation>::type;
template<class Invocation>
struct can_invoke:details::can_invoke<Invocation>{};

我们现在有 invoke_result_t<A(B,C)>，这是一个 SFINAE 友好的 result_of_t<A(B,C)> 和 can_invoke<A(B,C)>，它只是进行检查。

接下来，写一个move_only_function，一个只移动版本的std::function：

namespace details {
  template<class Sig>
  struct mof_internal;
  template<class R, class...Args>
  struct mof_internal {
    virtual ~mof_internal() {};
    // 4 overloads, because I'm insane:
    virtual R invoke( Args&&... args ) const& = 0;
    virtual R invoke( Args&&... args ) & = 0;
    virtual R invoke( Args&&... args ) const&& = 0;
    virtual R invoke( Args&&... args ) && = 0;
  };

  template<class F, class Sig>
  struct mof_pimpl;
  template<class R, class...Args, class F>
  struct mof_pimpl<F, R(Args...)>:mof_internal<R(Args...)> {
    F f;
    virtual R invoke( Args&&... args ) const&  override { return f( std::forward<Args>(args)... ); }
    virtual R invoke( Args&&... args )      &  override { return f( std::forward<Args>(args)... ); }
    virtual R invoke( Args&&... args ) const&& override { return std::move(f)( std::forward<Args>(args)... ); }
    virtual R invoke( Args&&... args )      && override { return std::move(f)( std::forward<Args>(args)... ); }
  };
}

template<class R, class...Args>
struct move_only_function<R(Args)> {
  move_only_function(move_only_function const&)=delete;
  move_only_function(move_only_function &&)=default;
  move_only_function(std::nullptr_t):move_only_function() {}
  move_only_function() = default;
  explicit operator bool() const { return pImpl; }
  bool operator!() const { return !*this; }
  R operator()(Args...args)     & { return                  pImpl().invoke(std::forward<Args>(args)...); }
  R operator()(Args...args)const& { return                  pImpl().invoke(std::forward<Args>(args)...); }
  R operator()(Args...args)     &&{ return std::move(*this).pImpl().invoke(std::forward<Args>(args)...); }
  R operator()(Args...args)const&&{ return std::move(*this).pImpl().invoke(std::forward<Args>(args)...); }

  template<class F,class=std::enable_if_t<can_invoke<decay_t<F>(Args...)>>
  move_only_function(F&& f):
    m_pImpl( std::make_unique<details::mof_pimpl<std::decay_t<F>, R(Args...)>>( std::forward<F>(f) ) )
  {}
private:
  using internal = details::mof_internal<R(Args...)>;
  std::unique_ptr<internal> m_pImpl;

  // rvalue helpers:
  internal      &  pImpl()      &  { return *m_pImpl.get(); }
  internal const&  pImpl() const&  { return *m_pImpl.get(); }
  internal      && pImpl()      && { return std::move(*m_pImpl.get()); }
  internal const&& pImpl() const&& { return std::move(*m_pImpl.get()); } // mostly useless
 };

未测试，只是吐出代码。 can_invoke 为构造函数提供了基本的 SFINAE——您可以根据需要添加 "return type converts properly" 和 "void return type means we ignore the return"。

现在我们重新编写您的代码。首先，您的任务是仅移动函数，而不是函数：

std::vector<move_only_function<X>> mTasks;

接下来我们将R类型的计算存储一次，再次使用：

template<class F, class... Args, class R=std::result_of_t<std::decay<F>_&&(std::decay_t<Args>&&...)>>
std::future<R>
push(F&& f, Args&&... args)
{
  auto tuple_args=std::make_tuple(std::forward<Args>(args)...)];

  // lambda will only be called once:
  std::packaged_task<R()> task([f=std::forward<F>(f),args=std::move(tuple_args)]
    return invoke_tuple( std::move(f), std::move(args) );
  });

   auto future = func.get_future();

  // for some reason I get a compilation error in clang if I get rid of the `=, ` in this capture:
  mTasks.emplace_back( std::move(task) );

  return future;
}

我们将参数填充到元组中，将该元组传递到 lambda 中，然后在 lambda 中以 "only do this once" 一种方式调用元组。由于我们只会调用该函数一次，因此我们针对这种情况优化了 lambda。

A packaged_task<R()> 与 move_only_function<R()> 兼容，与 std::function<R()> 不同，因此我们可以将其移动到向量中。我们从中得到的 std::future 应该可以正常工作，即使我们在 move.

之前得到它

这应该会稍微减少您的开销。当然，还有很多样板文件。

以上代码我都没有编译过，只是随便吐出来的，所以编译通过的几率很低。但错误应该主要是tpyos。

随机地，我决定给 move_only_function 4 个不同的 () 重载（rvalue/lvalue 和 const/not）。我本可以添加 volatile，但这似乎很鲁莽。无可否认，其中增加了样板文件。

我的 move_only_function 也缺少 std::function 具有的 "get at the underlying stored stuff" 操作。如果愿意，请随意键入擦除。并且它将 (R(*)(Args...))0 视为一个真正的函数指针（我 return true 转换为 bool 时，不像 null：转换为 [= 的类型擦除34=] 对于更具工业质量的实施可能是值得的。

我重写了 std::function，因为 std 缺少一个 std::move_only_function，并且这个概念总体上是有用的（如 packaged_task 所证明的）。您的解决方案通过用 std::shared_ptr.

包装来使您的可调用对象可移动

如果您不喜欢上面的样板文件，请考虑编写 make_copyable(F&&)，它接受一个函数对象 F 并使用您的 shared_ptr 技术将其包装起来以使其可复制。如果它已经可以复制，您甚至可以添加 SFINAE 以避免这样做（并将其称为 ensure_copyable）。

那么您的原始代码会更清晰，因为您只需使 packaged_task 可复制，然后存储它。

template<class F>
auto make_function_copyable( F&& f ) {
  auto sp = std::make_shared<std::decay_t<F>>(std::forward<F>(f));
  return [sp](auto&&...args){return (*sp)(std::forward<decltype(args)>(args)...); }
}
template<class F, class... Args, class R=std::result_of_t<std::decay<F>_&&(std::decay_t<Args>&&...)>>
std::future<R>
push(F&& f, Args&&... args)
{
  auto tuple_args=std::make_tuple(std::forward<Args>(args)...)];

  // lambda will only be called once:
  std::packaged_task<R()> task([f=std::forward<F>(f),args=std::move(tuple_args)]
    return invoke_tuple( std::move(f), std::move(args) );
  });

  auto future = func.get_future();

  // for some reason I get a compilation error in clang if I get rid of the `=, ` in this capture:
  mTasks.emplace_back( make_function_copyable( std::move(task) ) );

  return future;
}

这个还是需要上面的invoke_tuple样板，主要是我不喜欢bind.

如何将通用 packaged_tasks 存储在容器中？

How can I store generic packaged_tasks in a container?

c++

multithreading

c++11

c++14