I'm fairly familiar with the new standard library's
In the words of [futures.state] a
std::future is an asynchronous return object ("an object that reads results from a shared state") and a
std::promise is an asynchronous provider ("an object that provides a result to a shared state") i.e. a promise is the thing that you set a result on, so that you can get it from the associated future.
The asynchronous provider is what initially creates the shared state that a future refers to.
std::promise is one type of asynchronous provider,
std::packaged_task is another, and the internal detail of
std::async is another. Each of those can create a shared state and give you a
std::future that shares that state, and can make the state ready.
std::async is a higher-level convenience utility that gives you an asynchronous result object and internally takes care of creating the asynchronous provider and making the shared state ready when the task completes. You could emulate it with a
std::bind and a
std::promise) and a
std::thread but it's safer and easier to use
std::promise is a bit lower-level, for when you want to pass an asynchronous result to the future, but the code that makes the result ready cannot be wrapped up in a single function suitable for passing to
std::async. For example, you might have an array of several
promises and associated
futures and have a single thread which does several calculations and sets a result on each promise.
async would only allow you to return a single result, to return several you would need to call
async several times, which might waste resources.