“拼合”嵌套期货
问题描述:
我有我使用一个辅助功能“扁平化”嵌套期货成一个单一的未来:“拼合”嵌套期货
编辑:改名为“折”到“扁平化”的建议。
我使用的是期货从Boost库:
template<typename T>
auto flatten(boost::unique_future<T>&& f) -> boost::unique_future<decltype(f.get().get())>
{
auto shared_f = boost::shared_future<T>(std::move(f));
return async(launch_policy::deferred, [=]() mutable
{
return shared_f.get().get();
});
}
它这样使用:
auto nested_future_result = async([]() -> boost::shared_future<int>
{
auto tmp = async([]
{
return 1;
});
return boost::shared_future<int>(std::move(tmp));
});
boost::unique_future<int> future_result = flatten(nested_future_result);
int result = future_result.get();
的问题是,这只是作品,如果我转换“嵌套”的未来变成shared_future
。有没有什么好方法可以解决它?我想要的是这样的:
auto future_result = flatten(async([]
{
return async([]
{
return 1;
});
}));
int result = future_result.get();
其次,我有点不确定该方法的名称。有什么意见?
答
(注:我不明白你是怎么boost::unique_future
与std::async
合作,所以我替换boost::unique_future
所有实例std::future
的代码已经测试和工程在我结束)
的问题是, lambda表达式或者通过值来捕获(这实际上意味着通过拷贝捕获)或者通过引用(这里不适用,因为我们希望将未来的生命周期与我们的关闭联系起来),而std::future
是仅移动的。这个问题的答案通常是std::bind
,虽然在这种情况std::async
有一个内置的bind
样的功能:
template<typename T>
auto fold(std::future<T>&& f)
-> std::future<decltype(f.get().get())>
{
return std::async(std::launch::deferred, [](std::future<T>&& f)
{
return f.get().get();
}, std::move(f));
}
我没有一个好名字,建议我害怕。如果模板可能递归地将任何std::future<std::future<std::future<...std::future<T>...>>>
转换为std::future<T>
,那么也许我会打电话给flatten_future
。或者也许只是flatten
,因为毕竟它首先只接受std::future
。
假设我们已经有一个一元async
:
template<typename Functor, typename Arg, typename... Args>
auto async(Functor&& functor, Arg&& arg, Args&&.... args)
-> decltype(async(std::bind(std::forward<Functor>(functor)
, std::forward<Arg>(arg), std::forward<Args>(args)...)))
{
return async(std::bind(std::forward<Functor>(functor)
, std::forward<Arg>(arg), std::forward<Args>(args)...));
}
我写我自己的异步。只是意识到我不应该用'std'作为前缀。 – ronag 2012-02-18 10:15:31
您能否将该评论添加到您的答案中,如果没有格式化就很难阅读。 – ronag 2012-02-18 14:04:02
就像一个简单的问题,为什么不标准化的'std :: async'变平?这似乎是一个很自然的事情... – ronag 2012-02-18 14:07:12