What is the difference between future and shared_future?

Question

What is the difference between future and shared_future?
In what cases we must use shared_future instead of future?

I was trying to find good documentation that will contrast these two features of C++11, and I could not find an answer (easy/readable at least) on the web.

This is my current understanding of the differences

1. future object could be queried only once for the get().
2. shared_future could be queried any number of times.

use case: If multiple threads are dependent on the result of an asynchronous task, then we must use shared_future. If the future object needs be queried multiple times in the same thread then we must use shared_future instead.

Any more information, gotchas or general guidelines are welcome...

Answer 1

The motivation for these two future types goes back to move semantics, move-only types, and the new C++11 feature to return move-only types from ordinary functions.

In C++98/03, if you wanted to return a type from a factory function:

A
make_A()
{
    A a;
    // ...
    return a;
}

then A had to be CopyConstructible. Then, brand new in C++11, we can return A even if it is not CopyConstructible, it need only be MoveConstructible.

But what happens if you try to execute make_A concurrently, say using futures. Wouldn't it be a crime if you could only parallelize make_A if A is CopyConstructible?! You would have to give up one optimization while chasing another!

So future<R> only requires R to be MoveConstructible. But you can only get it once, because you're moving from the stored result.

But getting the same result for multiple threads is a real need too. So shared_future<R> allows that, but requires R to be CopyConstructible.