有没有办法在std :: experimental :: future中使用std :: async？

Question

Note: Below is illegal even in C++17!

#include <thread>
#include <future>
#include <experimental/future>

using namespace std;

int step1(experimental::future<int>)
{
    return {};
}

int step2(experimental::future<int>)
{
    return {};
}

int step3(experimental::future<int>)
{
    return {};
}

int main()
{
    return async([](){ return {}; })
        .then(step1)
        .then(step2)
        .then(step3)
        .get();
}

C++1z provides two types of future :

1. std::future
2. std:experimental::future

However, std::async returns std::future only, so the code above is illegal. If std::async returns std:experimental::future , then it would be ok.

My question is:

Is there a way to use std::async with std::experimental::future that makes the code above legal under C++1z?

Answer 1

Is there a way to use std::async with std::experimental::future that makes the code above legal under C++1z?

Nope. std::async returns a std::future<T> which, despite the name, is an entirely unrelated type to std::experimental::future<T> .

You would have to write your own version of async that gives you the new kind of future . A simplified version would be something like:

template <class F, class... Args,
    class R = std::invoke_result_t<std::decay_t<F>, std::decay_t<Args>...>>
std::experimental::future<R> new_async(F&& f, Args&&... args)
{
    std::experimental::promise<R> p;
    auto fut = p.get_future();

    std::thread thread([p=std::move(p), f=std::forward<F>(f),
        args=std::tuple<std::decay_t<Args>...>(std::forward<Args>(args)...)] () mutable
    {
        try 
        {
            if constexpr(std::is_void_v<R>)
            {
                std::apply(std::move(f), std::move(args));
                p.set_value();
            }
            else 
            {
                p.set_value(std::apply(std::move(f), std::move(args)));
            }
        }
        catch(...)
        {
            p.set_exception(std::current_exception());
        }
    });

    thread.detach();
    return fut;
}

That doesn't support other launch policies like async does, but it's just a start.

Answer 2

It seems like std::experimental::future has the same constructors as std::future , so it should be possible to construct an std::experimental::future from an std::future . However, as pointed out by ildjarn it actually isn't according to the latest draft , so there seems to be no way to do this until the TS changes accordingly.