将返回 std：：future 的函数调整为<T> std：：future<U>

假设我有一个异步函数映射原始映射，它将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()-风格延续）

我希望有一种有效的方法可以在相关类型的std::future s之间进行转换（或将std::future<T>施加到std::future<void>），但是这个问题的答案表明这是不可能的。

随机想法：

• async_for_each可以以一种巧妙的方式包装其功能来解决此问题？
• Container使用的类型可以像async_for_each中的void一样起作用，但可以像async_map中的Container一样行动？

我的最初尝试在下面。有可能在这些约束下构建我想要的东西吗？

#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;
}