调整返回std :: future的函数 <T> 到std :: future

Question

假设我有一个异步函数map原语，它将std::vector作为输入，并将std::future返回给我选择的Container作为输出：

template<class Container, class T, class Function>
std::future<Container> async_map(const std::vector<T>& in, Function f)
{
  return std::async([=]
  {
    Container result(in.size());

    for(size_t i = 0; i < in.size(); ++i)
    {
      result[i] = f(in[i]);
    }

    return result;
  });
} 

我想通过调整async_map来构建类似的async_for_each函数：

template<class T, class Function>
std::future<void> async_for_each(const std::vector<T>& in, Function f);

问题是async_for_each返回std::future<void> ，而async_map返回std::future<Container> ，而void不是Container 。

我可以通过构建这样一种类型，满足得到的东西接近我想要的Container要求，但忽略了分配给它（ empty_container在我最初的尝试），但是一个std::future这种类型依然没有std::future<void> 。

我对我的解决方案有以下限制：

• 必须只有一个async_map实现，具有给定的函数签名（即，没有async_map<void> ）
• 必须只创建一个std::future （即，没有.then() -style继续）

我希望有一种有效的方法来转换相关类型的std::future s（或者将std::future<T>为std::future<void> ），但这个问题的答案表明它不是可能。

随机的想法：

• async_for_each能以巧妙的方式包装其功能来解决这个问题吗？
• 用于Container的类型在async_for_each中async_for_each像void async_for_each ，但在async_map就像Container async_map ？

我的初步尝试如下。 考虑到这些限制，是否可以构建我想要的东西？

#include <future>
#include <vector>
#include <iostream>

template<class Container, class T, class Function>
std::future<Container> async_map(const std::vector<T>& in, Function f)
{
  return std::async([=]
  {
    Container result(in.size());

    for(size_t i = 0; i < in.size(); ++i)
    {
      result[i] = f(in[i]);
    }

    return result;
  });
}

struct empty_container
{
  empty_container(size_t) {}

  struct empty
  {
    template<class T>
    empty operator=(const T&) const { return empty(); }
  };

  empty operator[](size_t) { return empty(); }
};

template<class Function>
struct invoke_and_ignore_result
{
  Function f;

  template<class T>
  empty_container::empty operator()(T&& x) const
  {
    f(std::forward<T>(x));
    return empty_container::empty();
  }
};

template<class T, class Function>
//std::future<void> async_for_each(const std::vector<T>& in, Function f)
std::future<empty_container> async_for_each(const std::vector<T>& in, Function f)
{
  invoke_and_ignore_result<Function> g{f};

  std::future<empty_container> f1 = async_map<empty_container>(in, g);

  return f1;
}

int main()
{
  std::vector<int> vec(5, 13);

  async_for_each(vec, [](int x)
  {
    std::cout << x << " ";
  }).wait();

  std::cout << std::endl;

  return 0;
}

Answer 1

我认为你使用的是错误的原语。

在这里，我用不同的原语构建一切 - 一个接收器。

接收器可以通过operator()(T&&)&消耗数据。 然后它通过operator()()&&返回一些结果。

这是一个async_sink函数：

template<class Container, class Sink>
std::future<std::result_of_t<std::decay_t<Sink>()>>
async_sink(Container&& c, Sink&& sink)
{
  return std::async(
    [c=std::forward<Container>(c), sink=std::forward<Sink>(sink)]
  {
    for( auto&& x : std::move(c) ) {
      sink( x );
    }

    return std::move(sink)();
  });
} 

这里是一个的实现sink是把东西放进容器中，然后返回它：

template<class C>
struct container_sink_t {
  C c;
  template<class T>
  void operator()( T&& t ){
    c.emplace_back( std::forward<T>(t) );
  }
  C operator()()&&{
    return std::move(c);
  }
};

这是一个接收函数和接收器并构成它们的接收器：

template<class F, class S>
struct compose_sink_t {
  F f;
  S s;
  template<class T>
  void operator()(T&& t){
    s(
      f(std::forward<T>(t))
    );
  }
  std::result_of_t<S()> operator()()&&{
    return std::move(s)();
  }
};

template<class C, class F>
compose_sink_t<std::decay_t<F>, container_sink_t<C>>
transform_then_container_sink( F&& f ) {
  return {std::forward<F>(f)};
}

这是一个接收函数，调用它并返回void ：

template<class F>
struct void_sink_t {
  F f;
  template<class T>
  void operator()(T&& t)
  {
    f(std::forward<T>(t));
  }
  void operator()() {}
};
template<class F>
void_sink_t<std::decay_t<F>> void_sink(F&&f){return {std::forward<F>(f)}; }

现在你的地图是：

template<class Container, class T, class Function>
std::future<Container> async_map(const std::vector<T>& in, Function f)
{
  return async_sink(
    in,
    transform_then_container_sink<Container>(std::forward<F>(f))
  );
}

而你的for_each是：

template<class T, class Function>
std::future<void> async_for_each(const std::vector<T>& in, Function f)
{
  return async_sink(
    in,
    void_sink(std::forward<F>(f))
  );
}

我自由使用C ++ 14的功能，因为它们使代码更好。 您可以使用副本替换移入容器，以降低效率，并编写自己的_t别名。

上面的代码尚未经过测试或运行，因此可能存在漏洞。 有一个我不确定的问题 - lambda返回void是否可以在该上下文中return void_func() ？ - 但是因为丑陋在一个地方，即使它不起作用也可以解决。