Futures
Concurrency
Collaboration diagram for Futures:

## Classes

class | std::__basic_future< _Res >
struct | std::__future_base
struct | std::__future_base::_Result< _Res >
struct | std::__future_base::_Result< _Res & >
struct | std::__future_base::_Result< void >
struct | std::__future_base::_Result_alloc< _Res, _Alloc >
struct | std::__future_base::_Result_base
class | std::future< _Res >
class | std::future< _Res & >
class | std::future< void >
class | std::future_error
struct | std::is_error_code_enum< future_errc >
class | std::packaged_task< _Res(_ArgTypes...)>
class | std::promise< _Res >
class | std::promise< _Res & >
class | std::promise< void >
class | std::shared_future< _Res >
class | std::shared_future< _Res & >
class | std::shared_future< void >

## Typedefs

using | std::__future_base::_Result_alloc< _Res, _Alloc >::__allocator_type = __alloc_rebind< _Alloc, _Result_alloc >
template<typename _Fn , typename... _Args>
using | std::__async_result_of = typename result_of< typename decay< _Fn >::type(typename decay< _Args >::type...)>::type
typedef __future_base::_Result< _Res > & | std::__basic_future< _Res >::__result_type
typedef shared_ptr< _State_base > | std::__basic_future< _Res >::__state_type
typedef void | std::__constrain_pkgdtask< _Task, _Fn, bool >::__type
template<typename _Res >
using | std::__future_base::_Ptr = unique_ptr< _Res, _Result_base::_Deleter >
typedef __future_base::_Ptr< _Result< _Res > > | std::__future_base::_Task_state_base< _Res(_Args...)>::_Ptr_type
typedef _Res | std::__future_base::_Task_state_base< _Res(_Args...)>::_Res_type
using | std::__future_base::_State_base = _State_baseV2
typedef _Res | std::__future_base::_Result< _Res >::result_type
typedef _Res & | std::__future_base::_Result< _Res & >::result_type
typedef void | std::__future_base::_Result< void >::result_type

## Enumerations

enum | std::future_errc { future_already_retrieved, promise_already_satisfied, no_state, broken_promise }
enum | std::future_status { ready, timeout, deferred }
enum | std::launch { async, deferred }

## Functions

| std::__basic_future< _Res >::__basic_future (const __basic_future &)=delete
| std::__basic_future< _Res >::__basic_future (const __state_type &__state)
| std::__basic_future< _Res >::__basic_future (const shared_future< _Res > &) noexcept
| std::__basic_future< _Res >::__basic_future (future< _Res > &&) noexcept
| std::__basic_future< _Res >::__basic_future (shared_future< _Res > &&) noexcept
| std::__future_base::_Async_state_impl< _BoundFn, _Res >::_Async_state_impl (_BoundFn &&__fn)
| std::__future_base::_Deferred_state< _BoundFn, _Res >::_Deferred_state (_BoundFn &&__fn)
template<typename _Fn2 >
| std::__future_base::_Task_state< _Fn, _Alloc, _Res(_Args...)>::_Impl::_Impl (_Fn2 &&__fn, const _Alloc &__a)
| std::__basic_future< _Res >::_Reset::_Reset (__basic_future &__fut) noexcept
| std::__future_base::_Result_alloc< _Res, _Alloc >::_Result_alloc (const _Alloc &__a)
| std::__future_base::_Result_base::_Result_base (const _Result_base &)=delete
| std::__future_base::_State_baseV2::_State_baseV2 (const _State_baseV2 &)=delete
template<typename _Fn2 >
| std::__future_base::_Task_state< _Fn, _Alloc, _Res(_Args...)>::_Task_state (_Fn2 &&__fn, const _Alloc &__a)
template<typename _Alloc >
| std::__future_base::_Task_state_base< _Res(_Args...)>::_Task_state_base (const _Alloc &__a)
| std::future< _Res >::future (const future &)=delete
| std::future< _Res & >::future (const future &)=delete
| std::future< void >::future (const future &)=delete
| std::future< _Res >::future (future &&__uf) noexcept
| std::future< _Res & >::future (future &&__uf) noexcept
| std::future< void >::future (future &&__uf) noexcept
| std::future_error::future_error (future_errc __errc)
template<typename _Fn , typename = typename __constrain_pkgdtask<packaged_task, _Fn>::__type>
| std::packaged_task< _Res(_ArgTypes...)>::packaged_task (_Fn &&__fn)
template<typename _Fn , typename _Alloc , typename = typename __constrain_pkgdtask<packaged_task, _Fn>::__type>
| std::packaged_task< _Res(_ArgTypes...)>::packaged_task (allocator_arg_t, const _Alloc &__a, _Fn &&__fn)
template<typename _Allocator >
| std::packaged_task< _Res(_ArgTypes...)>::packaged_task (allocator_arg_t, const _Allocator &, const packaged_task &)=delete
template<typename _Allocator >
| std::packaged_task< _Res(_ArgTypes...)>::packaged_task (allocator_arg_t, const _Allocator &, packaged_task &&__other) noexcept
template<typename _Allocator >
| std::packaged_task< _Res(_ArgTypes...)>::packaged_task (allocator_arg_t, const _Allocator &__a) noexcept
| std::packaged_task< _Res(_ArgTypes...)>::packaged_task (const packaged_task &)=delete
| std::packaged_task< _Res(_ArgTypes...)>::packaged_task (packaged_task &&__other) noexcept
template<typename _Allocator >
| std::promise< _Res >::promise (allocator_arg_t, const _Allocator &, promise &&__rhs)
template<typename _Allocator >
| std::promise< _Res & >::promise (allocator_arg_t, const _Allocator &, promise &&__rhs)
template<typename _Allocator >
| std::promise< void >::promise (allocator_arg_t, const _Allocator &, promise &&__rhs)
template<typename _Allocator >
| std::promise< _Res >::promise (allocator_arg_t, const _Allocator &__a)
template<typename _Allocator >
| std::promise< _Res & >::promise (allocator_arg_t, const _Allocator &__a)
template<typename _Allocator >
| std::promise< void >::promise (allocator_arg_t, const _Allocator &__a)
| std::promise< _Res >::promise (const promise &)=delete
| std::promise< _Res & >::promise (const promise &)=delete
| std::promise< void >::promise (const promise &)=delete
| std::promise< _Res >::promise (promise &&__rhs) noexcept
| std::promise< _Res & >::promise (promise &&__rhs) noexcept
| std::promise< void >::promise (promise &&__rhs) noexcept
| std::shared_future< _Res & >::shared_future (const shared_future &__sf)
| std::shared_future< void >::shared_future (const shared_future &__sf)
| std::shared_future< _Res >::shared_future (const shared_future &__sf) noexcept
| std::shared_future< _Res & >::shared_future (future< _Res & > &&__uf) noexcept
| std::shared_future< _Res >::shared_future (future< _Res > &&__uf) noexcept
| std::shared_future< void >::shared_future (future< void > &&__uf) noexcept
| std::shared_future< _Res >::shared_future (shared_future &&__sf) noexcept
| std::shared_future< _Res & >::shared_future (shared_future &&__sf) noexcept
| std::shared_future< void >::shared_future (shared_future &&__sf) noexcept
template<typename _Signature , typename _Fn , typename _Alloc >
static shared_ptr< __future_base::_Task_state_base< _Signature > > | std::__create_task_state (_Fn &&__fn, const _Alloc &__a)
template<typename _Res >
static _Setter< _Res, __exception_ptr_tag > | std::__future_base::_State_baseV2::__setter (exception_ptr &__ex, promise< _Res > *__prom)
template<typename _Res >
static _Setter< _Res, void > | std::__future_base::_State_baseV2::__setter (promise< _Res > *__prom)
template<typename _Res , typename _Arg >
static _Setter< _Res, _Arg && > | std::__future_base::_State_baseV2::__setter (promise< _Res > *__prom, _Arg &&__arg)
void | std::__future_base::_State_baseV2::_M_break_promise (_Ptr_type __res)
virtual void | std::__future_base::_Async_state_commonV2::_M_complete_async ()
virtual void | std::__future_base::_Result_base::_M_destroy ()=0
_Res & | std::__future_base::_Result< _Res & >::_M_get () noexcept
__result_type | std::__basic_future< _Res >::_M_get_result () const
void | std::__future_base::_Async_state_commonV2::_M_join ()
virtual shared_ptr< _Task_state_base > | std::__future_base::_Task_state_base< _Res(_Args...)>::_M_reset ()=0
virtual void | std::__future_base::_Task_state_base< _Res(_Args...)>::_M_run (_Args &&... __args)=0
virtual void | std::__future_base::_Task_state_base< _Res(_Args...)>::_M_run_delayed (_Args &&... __args, weak_ptr< _State_base >)=0
void | std::__future_base::_State_baseV2::_Make_ready::_M_set ()
void | std::__future_base::_Result< _Res >::_M_set (_Res &&__res)
void | std::__future_base::_Result< _Res & >::_M_set (_Res &__res) noexcept
void | std::__future_base::_Result< _Res >::_M_set (const _Res &__res)
void | std::__future_base::_State_baseV2::_M_set_delayed_result (function< _Ptr_type()> __res, weak_ptr< _State_baseV2 > __self)
void | std::__future_base::_State_baseV2::_M_set_result (function< _Ptr_type()> __res, bool __ignore_failure=false)
void | std::__future_base::_State_baseV2::_M_set_retrieved_flag ()
void | std::__basic_future< _Res >::_M_swap (__basic_future &__that) noexcept
_Res & | std::__future_base::_Result< _Res >::_M_value () noexcept
template<typename _Res , typename _Allocator >
static _Ptr< _Result_alloc< _Res, _Allocator > > | std::__future_base::_S_allocate_result (const _Allocator &__a)
template<typename _Res , typename _Tp >
static _Ptr< _Result< _Res > > | std::__future_base::_S_allocate_result (const std::allocator< _Tp > &__a)
template<typename _Tp >
static void | std::__future_base::_State_baseV2::_S_check (const shared_ptr< _Tp > &__p)
template<typename _BoundFn >
static std::shared_ptr< _State_base > | std::__future_base::_S_make_async_state (_BoundFn &&__fn)
template<typename _BoundFn >
static std::shared_ptr< _State_base > | std::__future_base::_S_make_deferred_state (_BoundFn &&__fn)
static void | std::__future_base::_State_baseV2::_Make_ready::_S_run (void *)
template<typename _Res_ptr , typename _BoundFn >
static _Task_setter< _Res_ptr, _BoundFn > | std::__future_base::_S_task_setter (_Res_ptr &__ptr, _BoundFn &__call)
template<typename _Fn , typename... _Args>
future< __async_result_of< _Fn, _Args... > > | std::async (_Fn &&__fn, _Args &&... __args)
template<typename _Fn , typename... _Args>
future< __async_result_of< _Fn, _Args... > > | std::async (launch __policy, _Fn &&__fn, _Args &&... __args)
const error_code & | std::future_error::code () const noexcept
const error_category & | std::future_category () noexcept
_Res | std::future< _Res >::get ()
_Res & | std::future< _Res & >::get ()
void | std::future< void >::get ()
const _Res & | std::shared_future< _Res >::get () const
_Res & | std::shared_future< _Res & >::get () const
void | std::shared_future< void >::get () const
future< _Res > | std::promise< _Res >::get_future ()
future< _Res & > | std::promise< _Res & >::get_future ()
future< void > | std::promise< void >::get_future ()
future< _Res > | std::packaged_task< _Res(_ArgTypes...)>::get_future ()
error_code | std::make_error_code (future_errc __errc) noexcept
error_condition | std::make_error_condition (future_errc __errc) noexcept
void | std::packaged_task< _Res(_ArgTypes...)>::make_ready_at_thread_exit (_ArgTypes... __args)
constexpr launch | std::operator& (launch __x, launch __y)
launch & | std::operator&= (launch &__x, launch __y)
promise< _Res >::_Ptr_type | std::__future_base::_State_baseV2::_Setter< _Res, _Arg & >::operator() () const
promise< _Res >::_Ptr_type | std::__future_base::_State_baseV2::_Setter< _Res, _Res && >::operator() () const
promise< _Res >::_Ptr_type | std::__future_base::_State_baseV2::_Setter< _Res, void >::operator() () const
promise< _Res >::_Ptr_type | std::__future_base::_State_baseV2::_Setter< _Res, __exception_ptr_tag >::operator() () const
_Ptr_type | std::__future_base::_Task_setter< _Ptr_type, _Fn, _Res >::operator() () const
_Ptr_type | std::__future_base::_Task_setter< _Ptr_type, _Fn, void >::operator() () const
void | std::packaged_task< _Res(_ArgTypes...)>::operator() (_ArgTypes... __args)
void | std::__future_base::_Result_base::_Deleter::operator() (_Result_base *__fr) const
__basic_future & | std::__basic_future< _Res >::operator= (const __basic_future &)=delete
_Result_base & | std::__future_base::_Result_base::operator= (const _Result_base &)=delete
_State_baseV2 & | std::__future_base::_State_baseV2::operator= (const _State_baseV2 &)=delete
future & | std::future< _Res >::operator= (const future &)=delete
future & | std::future< _Res & >::operator= (const future &)=delete
future & | std::future< void >::operator= (const future &)=delete
packaged_task & | std::packaged_task< _Res(_ArgTypes...)>::operator= (const packaged_task &)=delete
promise & | std::promise< _Res >::operator= (const promise &)=delete
promise & | std::promise< _Res & >::operator= (const promise &)=delete
promise & | std::promise< void >::operator= (const promise &)=delete
shared_future & | std::shared_future< _Res & >::operator= (const shared_future &__sf)
shared_future & | std::shared_future< void >::operator= (const shared_future &__sf)
shared_future & | std::shared_future< _Res >::operator= (const shared_future &__sf) noexcept
future & | std::future< _Res >::operator= (future &&__fut) noexcept
future & | std::future< _Res & >::operator= (future &&__fut) noexcept
future & | std::future< void >::operator= (future &&__fut) noexcept
packaged_task & | std::packaged_task< _Res(_ArgTypes...)>::operator= (packaged_task &&__other) noexcept
promise & | std::promise< _Res >::operator= (promise &&__rhs) noexcept
promise & | std::promise< _Res & >::operator= (promise &&__rhs) noexcept
promise & | std::promise< void >::operator= (promise &&__rhs) noexcept
shared_future & | std::shared_future< _Res >::operator= (shared_future &&__sf) noexcept
shared_future & | std::shared_future< _Res & >::operator= (shared_future &&__sf) noexcept
shared_future & | std::shared_future< void >::operator= (shared_future &&__sf) noexcept
constexpr launch | std::operator^ (launch __x, launch __y)
launch & | std::operator^= (launch &__x, launch __y)
constexpr launch | std::operator| (launch __x, launch __y)
launch & | std::operator|= (launch &__x, launch __y)
constexpr launch | std::operator~ (launch __x)
void | std::packaged_task< _Res(_ArgTypes...)>::reset ()
void | std::promise< _Res >::set_exception (exception_ptr __p)
void | std::promise< _Res & >::set_exception (exception_ptr __p)
void | std::promise< void >::set_exception (exception_ptr __p)
void | std::promise< _Res >::set_exception_at_thread_exit (exception_ptr __p)
void | std::promise< _Res & >::set_exception_at_thread_exit (exception_ptr __p)
void | std::promise< void >::set_exception_at_thread_exit (exception_ptr __p)
void | std::promise< void >::set_value ()
void | std::promise< _Res >::set_value (_Res &&__r)
void | std::promise< _Res & >::set_value (_Res &__r)
void | std::promise< _Res >::set_value (const _Res &__r)
void | std::promise< void >::set_value_at_thread_exit ()
void | std::promise< _Res >::set_value_at_thread_exit (_Res &&__r)
void | std::promise< _Res & >::set_value_at_thread_exit (_Res &__r)
void | std::promise< _Res >::set_value_at_thread_exit (const _Res &__r)
shared_future< _Res > | std::future< _Res >::share () noexcept
shared_future< _Res & > | std::future< _Res & >::share () noexcept
shared_future< void > | std::future< void >::share () noexcept
void | std::packaged_task< _Res(_ArgTypes...)>::swap (packaged_task &__other) noexcept
template<typename _Res , typename... _ArgTypes>
void | std::swap (packaged_task< _Res(_ArgTypes...)> &__x, packaged_task< _Res(_ArgTypes...)> &__y) noexcept
void | std::promise< _Res >::swap (promise &__rhs) noexcept
void | std::promise< _Res & >::swap (promise &__rhs) noexcept
void | std::promise< void >::swap (promise &__rhs) noexcept
template<typename _Res >
void | std::swap (promise< _Res > &__x, promise< _Res > &__y) noexcept
bool | std::__basic_future< _Res >::valid () const noexcept
bool | std::packaged_task< _Res(_ArgTypes...)>::valid () const noexcept
_Result_base & | std::__future_base::_State_baseV2::wait ()
void | std::__basic_future< _Res >::wait () const
template<typename _Rep , typename _Period >
future_status | std::__future_base::_State_baseV2::wait_for (const chrono::duration< _Rep, _Period > &__rel)
template<typename _Rep , typename _Period >
future_status | std::__basic_future< _Res >::wait_for (const chrono::duration< _Rep, _Period > &__rel) const
template<typename _Clock , typename _Duration >
future_status | std::__future_base::_State_baseV2::wait_until (const chrono::time_point< _Clock, _Duration > &__abs)
template<typename _Clock , typename _Duration >
future_status | std::__basic_future< _Res >::wait_until (const chrono::time_point< _Clock, _Duration > &__abs) const
virtual const char * | std::future_error::what () const noexcept

## Variables

_Arg * | std::__future_base::_State_baseV2::_Setter< _Res, _Arg & >::_M_arg
_Res * | std::__future_base::_State_baseV2::_Setter< _Res, _Res && >::_M_arg
exception_ptr | std::__future_base::_Result_base::_M_error
exception_ptr * | std::__future_base::_State_baseV2::_Setter< _Res, __exception_ptr_tag >::_M_ex
_Fn * | std::__future_base::_Task_setter< _Ptr_type, _Fn, _Res >::_M_fn
_Fn * | std::__future_base::_Task_setter< _Ptr_type, _Fn, void >::_M_fn
_Fn | std::__future_base::_Task_state< _Fn, _Alloc, _Res(_Args...)>::_Impl::_M_fn
__basic_future & | std::__basic_future< _Res >::_Reset::_M_fut
once_flag | std::__future_base::_Async_state_commonV2::_M_once
promise< _Res > * | std::__future_base::_State_baseV2::_Setter< _Res, _Arg & >::_M_promise
promise< _Res > * | std::__future_base::_State_baseV2::_Setter< _Res, _Res && >::_M_promise
promise< _Res > * | std::__future_base::_State_baseV2::_Setter< _Res, void >::_M_promise
promise< _Res > * | std::__future_base::_State_baseV2::_Setter< _Res, __exception_ptr_tag >::_M_promise
_Ptr_type * | std::__future_base::_Task_setter< _Ptr_type, _Fn, _Res >::_M_result
_Ptr_type * | std::__future_base::_Task_setter< _Ptr_type, _Fn, void >::_M_result
_Ptr_type | std::__future_base::_Task_state_base< _Res(_Args...)>::_M_result
weak_ptr< _State_baseV2 > | std::__future_base::_State_baseV2::_Make_ready::_M_shared_state
thread | std::__future_base::_Async_state_commonV2::_M_thread

## Friends

void | std::future_error::__throw_future_error (int)
template<typename , typename >
class | std::promise< _Res >::_State::_Setter
template<typename , typename >
class | std::promise< _Res & >::_State::_Setter
template<typename , typename >
class | std::promise< void >::_State::_Setter
template<typename _Fn , typename... _Args>
future< __async_result_of< _Fn, _Args... > > | std::future< _Res >::async (launch, _Fn &&, _Args &&...)
template<typename _Fn , typename... _Args>
future< __async_result_of< _Fn, _Args... > > | std::future< _Res & >::async (launch, _Fn &&, _Args &&...)
template<typename _Fn , typename... _Args>
future< __async_result_of< _Fn, _Args... > > | std::future< void >::async (launch, _Fn &&, _Args &&...)
template<typename >
class | std::future< _Res >::packaged_task
template<typename >
class | std::future< _Res & >::packaged_task
template<typename >
class | std::future< void >::packaged_task
class | std::future< _Res & >::promise< _Res & >
class | std::future< _Res >::promise< _Res >
class | std::future< void >::promise< void >

## Detailed Description

Classes for futures support.

## Typedef Documentation

## _Ptr

template<typename _Res >

using std::__future_base::_Ptr = unique_ptr<_Res, _Result_base::_Deleter>

A unique_ptr for result objects.

Definition at line 223 of file future.

## Enumeration Type Documentation

## future_errc

enum std::future_errc

strong

Error code for futures.

Definition at line 66 of file future.

## future_status

enum std::future_status

strong

Status code for futures.

Definition at line 174 of file future.

## launch

enum std::launch

strong

Launch code for futures.

Definition at line 137 of file future.

## Function Documentation

## future() [1/3]

template<typename _Res >

std::future< _Res >::future | ( | future< _Res > && | __uf | ) |

inline noexcept

Move constructor.

Definition at line 779 of file future.

## future() [2/3]

template<typename _Res >

std::future< _Res & >::future | ( | future< _Res & > && | __uf | ) |

inline noexcept

Move constructor.

Definition at line 822 of file future.

## future() [3/3]

std::future< void >::future | ( | future< void > && | __uf | ) |

inline noexcept

Move constructor.

Definition at line 865 of file future.

## shared_future() [1/9]

template<typename _Res >

std::shared_future< _Res & >::shared_future | ( | const shared_future< _Res & > & | __sf | ) |

inline

Copy constructor.

Definition at line 938 of file future.

## shared_future() [2/9]

std::shared_future< void >::shared_future | ( | const shared_future< void > & | __sf | ) |

inline

Copy constructor.

Definition at line 977 of file future.

## shared_future() [3/9]

template<typename _Res >

std::shared_future< _Res >::shared_future | ( | const shared_future< _Res > & | __sf | ) |

inline noexcept

Copy constructor.

Definition at line 899 of file future.

## shared_future() [4/9]

template<typename _Res >

std::shared_future< _Res & >::shared_future | ( | future< _Res & > && | __uf | ) |

inline noexcept

Construct from a future rvalue.

Definition at line 941 of file future.

## shared_future() [5/9]

template<typename _Res >

std::shared_future< _Res >::shared_future | ( | future< _Res > && | __uf | ) |

inline noexcept

Construct from a future rvalue.

Definition at line 902 of file future.

## shared_future() [6/9]

std::shared_future< void >::shared_future | ( | future< void > && | __uf | ) |

inline noexcept

Construct from a future rvalue.

Definition at line 980 of file future.

## shared_future() [7/9]

template<typename _Res >

std::shared_future< _Res >::shared_future | ( | shared_future< _Res > && | __sf | ) |

inline noexcept

Construct from a shared_future rvalue.

Definition at line 907 of file future.

## shared_future() [8/9]

template<typename _Res >

std::shared_future< _Res & >::shared_future | ( | shared_future< _Res & > && | __sf | ) |

inline noexcept

Construct from a shared_future rvalue.

Definition at line 946 of file future.

## shared_future() [9/9]

std::shared_future< void >::shared_future | ( | shared_future< void > && | __sf | ) |

inline noexcept

Construct from a shared_future rvalue.

Definition at line 985 of file future.

## _M_get_result()

template<typename _Res >

__result_type std::__basic_future< _Res >::_M_get_result | ( |  | ) | const

inline protected

Wait for the state to be ready and rethrow any stored exception.

Definition at line 714 of file future.

## async() [1/2]

template<typename _Fn , typename... _Args>

future< __async_result_of< _Fn, _Args... > > std::async | ( | _Fn && | __fn,
|  | _Args &&... | __args
| ) |  |

inline

async, potential overload

Definition at line 1745 of file future.

## async() [2/2]

template<typename _Fn , typename... _Args>

future< __async_result_of< _Fn, _Args... > > std::async | ( | launch | __policy,
|  | _Fn && | __fn,
|  | _Args &&... | __args
| ) |  |

async

Definition at line 1712 of file future.

## future_category()

const error_category& std::future_category | ( |  | ) |

noexcept

Points to a statically-allocated object derived from error_category.

## get() [1/5]

template<typename _Res >

_Res std::future< _Res >::get | ( |  | ) |

inline

Retrieving the value.

Definition at line 793 of file future.

## get() [2/5]

template<typename _Res >

_Res& std::future< _Res & >::get | ( |  | ) |

inline

Retrieving the value.

Definition at line 836 of file future.

## get() [3/5]

void std::future< void >::get | ( |  | ) |

inline

Retrieving the value.

Definition at line 879 of file future.

## get() [4/5]

template<typename _Res >

const _Res& std::shared_future< _Res >::get | ( |  | ) | const

inline

Retrieving the value.

Definition at line 925 of file future.

## get() [5/5]

template<typename _Res >

_Res& std::shared_future< _Res & >::get | ( |  | ) | const

inline

Retrieving the value.

Definition at line 964 of file future.

## make_error_code()

error_code std::make_error_code | ( | future_errc | __errc | ) |

inline noexcept

Overload for make_error_code.

Definition at line 84 of file future.

## make_error_condition()

error_condition std::make_error_condition | ( | future_errc | __errc | ) |

inline noexcept

Overload for make_error_condition.

Definition at line 89 of file future.

## swap()

template<typename _Res , typename... _ArgTypes>

void std::swap | ( | packaged_task< _Res(_ArgTypes...)> & | __x,
|  | packaged_task< _Res(_ArgTypes...)> & | __y
| ) |  |

inline noexcept

swap

Definition at line 1579 of file future.

## what()

virtual const char* std::future_error::what | ( |  | ) | const

virtual noexcept

Returns a C-style character string describing the general cause of the current error (the same string passed to the ctor).

Reimplemented from std::logic_error.