33
Concurrency support library
[thread]
33.10
Futures
[futures]
33.10.10
Class template
packaged_
task
[futures.task]
33.10.10.1
General
[futures.task.general]
1
#
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
)
;
~
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
>
;
}