Difference between revisions of "cpp/thread/packaged task"
From cppreference.com
m (Text replace - "{{concept" to "{{named req") |
(LWG 3117) |
||
| Line 44: | Line 44: | ||
{{dsc inc | cpp/thread/packaged_task/dsc uses_allocator}} | {{dsc inc | cpp/thread/packaged_task/dsc uses_allocator}} | ||
{{dsc end}} | {{dsc end}} | ||
| + | |||
| + | ==={{rl|deduction_guides|Deduction guides}}{{mark since c++17}}=== | ||
===Example=== | ===Example=== | ||
| Line 101: | Line 103: | ||
task_thread: 1024 | task_thread: 1024 | ||
}} | }} | ||
| + | |||
| + | ===Defect reports=== | ||
| + | {{dr list begin}} | ||
| + | {{dr list item|wg=lwg|dr=3117|std=C++17|before=deduction guides for {{tt|packaged_task}} was missing|after=added}} | ||
| + | {{dr list end}} | ||
===See also=== | ===See also=== | ||
| Line 107: | Line 114: | ||
{{dsc end}} | {{dsc end}} | ||
| − | + | {{langlinks|de|es|fr|it|ja|pt|ru|zh}} | |
| − | + | ||
| − | + | ||
| − | + | ||
| − | + | ||
| − | + | ||
| − | + | ||
| − | + | ||
Revision as of 09:25, 13 November 2020
| Defined in header <future>
|
||
| template< class > class packaged_task; //not defined |
(1) | (since C++11) |
| template< class R, class ...Args > class packaged_task<R(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. Its return value or exception thrown is stored in a shared state which can be accessed through std::future objects.
|
Just like std::function, |
(until C++17) |
Contents |
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) | |
Execution | |
| 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) | |
Non-member functions
| specializes the std::swap algorithm (function template) |
Helper classes
| (C++11) (until C++17) |
specializes the std::uses_allocator type trait (class template specialization) |
Deduction guides(since C++17)
Example
Run this code
#include <iostream> #include <cmath> #include <thread> #include <future> #include <functional> // unique function to avoid disambiguating the std::pow overload set int f(int x, int y) { return std::pow(x,y); } void task_lambda() { std::packaged_task<int(int,int)> task([](int a, int b) { return std::pow(a, b); }); std::future<int> result = task.get_future(); task(2, 9); std::cout << "task_lambda:\t" << result.get() << '\n'; } void task_bind() { std::packaged_task<int()> task(std::bind(f, 2, 11)); std::future<int> result = task.get_future(); task(); std::cout << "task_bind:\t" << result.get() << '\n'; } void task_thread() { std::packaged_task<int(int,int)> task(f); std::future<int> result = task.get_future(); std::thread task_td(std::move(task), 2, 10); task_td.join(); std::cout << "task_thread:\t" << result.get() << '\n'; } int main() { task_lambda(); task_bind(); task_thread(); }
Output:
task_lambda: 512 task_bind: 2048 task_thread: 1024
Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
| DR | Applied to | Behavior as published | Correct behavior |
|---|---|---|---|
| LWG 3117 | C++17 | deduction guides for packaged_task was missing
|
added |
See also
| (C++11) |
waits for a value that is set asynchronously (class template) |
