（34）全局函 async (…) ， 接着开始介绍这个重要的函数，使用这个函数，可以从线程中得到函数的返回值。用 thread 类创建的线程是无法从中得到线程中函数的返回值的。

template <class _Fret> // type for functions returning T，本模板处理函数的返回值类型
struct _P_arg_type         { using type = _Fret; };

template <class _Fret> // type for functions returning reference to T
struct _P_arg_type<_Fret&> { using type = _Fret*; };

template <>            // type for functions returning void
struct _P_arg_type<void>   { using type = int; };

//********************************

// manages a callable object launched with supplied policy
template <class _Fty, class... _ArgTypes> // future<T>、future<T&>、future<void> 等
future<_Invoke_result_t<decay_t<_Fty>, decay_t<_ArgTypes>...>> // 函数返回值 // 管理使用提供的策略启动的可调用对象
async(launch _Policy, _Fty&& _Fnarg, _ArgTypes&&... _Args) 
{
    using _Ret = _Invoke_result_t<decay_t<_Fty>, decay_t<_ArgTypes>...>; // 简写函数的返回值类型
    using _Ptype = typename _P_arg_type<_Ret>::type; // 对在线程中执行的函数的返回值的类型进行必要的转换

    _Promise<_Ptype> _Pr(_Get_associated_state<_Ret>(_Policy,
       _Fake_no_copy_callable_adapter<_Fty, _ArgTypes...>
       						 (_STD forward<_Fty>(_Fnarg), _STD forward<_ArgTypes>(_Args)...)
                                                     )
                          );
/*
_State_manager<Ty> { _Associated_state<Ty>* _Assoc_state; bool _Get_only_once; };

template <class _Ty>  // 注意前导的下划线 _Promise
class _Promise
{   
    _State_manager<_Ty> _State; bool _Future_retrieved; // 函数的返回值是否已交给 future 管理

    _Promise(_Associated_state<_Ty>* _State_ptr)   // 有参构造函数
        : _State(_State_ptr, false), _Future_retrieved(false) {}

    // 给 future 后，就不能再通过本 _Promise 使用函数返回值  // 返回结果是左值引用
    _State_manager<_Ty>& _Get_state_for_future() { _Future_retrieved = true;  return _State; }
};

template <class _Ty>
class future : public _State_manager<_Ty>
{
    using _Mybase = _State_manager<_Ty>;
    future(const _Mybase& _State, _Nil) : _Mybase(_State, true) {}
};
*/
    return future<_Ret>(_Pr._Get_state_for_future(), _Nil()); // 调用了 future 的某版本的构造函数
}

template <class _Fty, class... _ArgTypes> // 推导结果就是 future< 函数返回值 >
future<_Invoke_result_t<decay_t<_Fty>, decay_t<_ArgTypes>...>>  // 管理使用默认策略启动的可调用对象
async(_Fty&& _Fnarg, _ArgTypes&&... _Args) // manages a callable object launched启动 with default policy
{
    return _STD async( launch::async | launch::deferred,
                        _STD forward<_Fty>(_Fnarg), _STD forward<_ArgTypes>(_Args)...);
}

++ 看着代码没有几行。但充分的理解代码，需要参考前面几篇文章整理的内容，那些模板类，模板函数。

（35）

（36）

谢谢