Defined in header <future>
template< class > class packaged_task; //not defined
(1) (since C++11)
template< class Function, class Args... >
class packaged_task<Function(Args...)>;
(2) (since C++11)

The class template std::packaged_task wraps any callable target (function, lambda expression, bind expression, or another function object) so that it can be invoked asynchronously, and its return value or exception thrown is stored in the shared state, which can be accessed through std::future objects.

Just like std::function, std::packaged_task is a polymorphic, allocator-aware container: the stored callable target may be allocated on heap or with a provided allocator.


[edit] Member functions

constructs the task object
(public member function)
destructs the task object
(public member function)
moves the task object
(public member function)
checks if the task object has a valid function
(public member function)
swaps two task objects
(public member function)
Getting the result
returns a std::future associated with the promised result
(public member function)
executes the function
(public member function)
executes the function ensuring that the result is ready
only once the current thread exits
(public member function)
resets the state abandoning any stored results of previous executions
(public member function)

[edit] Non-member functions

specializes the std::swap algorithm
(function template)

[edit] Helper classes

specializes the std::uses_allocator type trait
(class template specialization)

[edit] Example

#include <iostream>
#include <future>
#include <thread>
int main()
    std::packaged_task<int()> task([](){return 7;}); // wrap the function
    std::future<int> result = task.get_future();  // get a future
    std::thread(std::move(task)).detach(); // launch on a thread
    std::cout << "Waiting...";
    std::cout << "Done!\nResult is " << result.get() << '\n';


Result is 7

[edit] See also

waits for a value that is set asynchronously
(class template)