std::future (3) - Linux Manuals

std::future: std::future


std::future - std::future


Defined in header <future>
template< class T > class future; (1) (since C++11)
template< class T > class future<T&>; (2) (since C++11)
template<> class future<void>; (3) (since C++11)

The class template std::future provides a mechanism to access the result of asynchronous operations:

* An asynchronous operation (created via std::async, std::packaged_task, or std::promise) can provide a std::future object to the creator of that asynchronous operation.

* The creator of the asynchronous operation can then use a variety of methods to query, wait for, or extract a value from the std::future. These methods may block if the asynchronous operation has not yet provided a value.

* When the asynchronous operation is ready to send a result to the creator, it can do so by modifying shared state (e.g. std::promise::set_value) that is linked to the creator's std::future.

Note that std::future references shared state that is not shared with any other asynchronous return objects (as opposed to std::shared_future).

Member functions

              constructs the future object
constructor (public member function)
              destructs the future object
destructor (public member function)
              moves the future object
operator= (public member function)
              transfers the shared state from *this to a shared_future and returns it
share (public member function)

Getting the result

              returns the result
get (public member function)


              checks if the future has a shared state
valid (public member function)
              waits for the result to become available
wait (public member function)
              waits for the result, returns if it is not available for the specified timeout duration
wait_for (public member function)
              waits for the result, returns if it is not available until specified time point has been reached
wait_until (public member function)


// Run this code

  #include <iostream>
  #include <future>
  #include <thread>

  int main()
      // future from a packaged_task
      std::packaged_task<int()> task([]{ return 7; }); // wrap the function
      std::future<int> f1 = task.get_future(); // get a future
      std::thread t(std::move(task)); // launch on a thread

      // future from an async()
      std::future<int> f2 = std::async(std::launch::async, []{ return 8; });

      // future from a promise
      std::promise<int> p;
      std::future<int> f3 = p.get_future();
      std::thread( [&p]{ p.set_value_at_thread_exit(9); }).detach();

      std::cout << "Waiting..." << std::flush;
      std::cout << "Done!\nResults are: "
                << f1.get() << ' ' << f2.get() << ' ' << f3.get() << '\n';


  Results are: 7 8 9

See also

async runs a function asynchronously (potentially in a new thread) and returns a std::future that will hold the result
              (function template)

shared_future waits for a value (possibly referenced by other futures) that is set asynchronously
              (class template)