#
The class template
packaged_
task
defines a type for wrapping a function or callable object so that the return value of the function or callable object is stored in a future when it is invoked
.
2
#
When the
packaged_
task
object is invoked, its stored task is invoked and the result (whether normal or exceptional) stored in the shared state
.
Any futures that share the shared state will then be able to access the stored result
.
🔗
namespace
std
{
template
<
class
>
class
packaged_task;
/
not defined
template
<
class
R,
class
.
ArgTypes
>
class
packaged_task
<
R
(
ArgTypes
.
.
)
>
{
public
:
/ construction and destruction
packaged_task
(
)
noexcept
;
template
<
class
F
>
explicit
packaged_task
(
F
&
&
f
)
;
template
<
class
F,
class
Allocator
>
explicit
packaged_task
(
allocator_arg_t,
const
Allocator
&
a, F
&
&
f
)
;
~
packaged_task
(
)
;
/ no copy
packaged_task
(
const
packaged_task
&
)
=
delete
; packaged_task
&
operator
=
(
const
packaged_task
&
)
=
delete
;
/ move support
packaged_task
(
packaged_task
&
&
rhs
)
noexcept
; packaged_task
&
operator
=
(
packaged_task
&
&
rhs
)
noexcept
;
void
swap
(
packaged_task
&
other
)
noexcept
;
bool
valid
(
)
const
noexcept
;
/ result retrieval
future
<
R
>
get_future
(
)
;
/ execution
void
operator
(
)
(
ArgTypes
.
.
)
;
void
make_ready_at_thread_exit
(
ArgTypes
.
.
)
;
void
reset
(
)
;
}
;
template
<
class
R,
class
.
ArgTypes
>
packaged_task
(
R
(
*
)
(
ArgTypes
.
.
)
-
>
packaged_task
<
R
(
ArgTypes
.
.
)
>
;
template
<
class
F
>
packaged_task
(
F
)
-
>
packaged_task
<
see below
>
;
}