命名空间
变体
操作

标准库头文件 <future> (C++11)

来自 cppreference.com
< cpp‎ | header
 
C++
 
标准库头文件
语言支持
概念
<concepts> (C++20)
诊断
<system_error> (C++11)

内存管理
<memory_resource> (C++17)  
元编程
<type_traits> (C++11)
<ratio> (C++11)
通用实用工具
<utility>
<tuple> (C++11)
<optional> (C++17)
<variant> (C++17)
<any> (C++17)
<debugging> (C++26)
<expected> (C++23)
<bitset>
<charconv> (C++17)
<format> (C++20)
<bit> (C++20)

字符串
<cuchar> (C++11)

容器
<flat_set> (C++23)
<span> (C++20)
<mdspan> (C++23)
<inplace_vector> (C++26)
迭代器
<iterator>
范围
<ranges> (C++20)
<generator> (C++23)
算法
数值
<cfenv> (C++11)
<complex>
<cmath>
<linalg> (C++26)
<numbers> (C++20)

时间
<chrono> (C++11)
本地化
<codecvt> (C++11/17/26*)
<text_encoding> (C++26)
输入/输出
<filesystem> (C++17)
<cstdio>
<cinttypes> (C++11)
<strstream> (C++98/26*)
正则表达式
<regex> (C++11)
并发支持
<stop_token> (C++20)
<thread> (C++11)
<atomic> (C++11)
<rcu> (C++26)
<stdatomic.h> (C++23)
<mutex> (C++11)
<shared_mutex> (C++14)

<condition_variable> (C++11)  
<semaphore> (C++20)
<latch> (C++20)

<barrier> (C++20)
<future> (C++11)
<hazard_pointer> (C++26)

C 兼容性
<cstdbool> (C++11/17/20*)  
<ccomplex> (C++11/17/20*)
<ctgmath> (C++11/17/20*)

<cstdalign> (C++11/17/20*)

<ciso646> (直到 C++20)

 

此头文件是 线程支持 库的一部分。

内容

类

(C++11)
 存储一个用于异步检索的值
(类模板) [edit]
(C++11)
 打包一个函数以存储其返回值用于异步检索
(类模板) [编辑]
(C++11)
 等待异步设置的值
(类模板) [编辑]
(C++11)
 等待异步设置的值（可能被其他 future 引用）
(类模板) [编辑]
(C++11)
 指定 std::async 的启动策略
(枚举) [编辑]
(C++11)
 指定对 std::future 和 std::shared_future 执行的定时等待的结果
(枚举) [编辑]
(C++11)
 报告与 future 或 promise 相关的错误
(类) [编辑]
(C++11)
 标识 future 错误代码
(枚举) [编辑]
(C++11)
 专门化 std::uses_allocator 类型特征
(类模板特化) [编辑]
(C++11) (直到 C++17)
 专门化 std::uses_allocator 类型特征
(类模板特化) [编辑]

函数

(C++11)
 异步运行函数（可能在新线程中），并返回一个将保存结果的 std::future
(函数模板) [编辑]
(C++11)
 标识 future 错误类别
(函数) [编辑]
(C++11)
 专门化 std::swap 算法
(函数模板) [编辑]
(C++11)
 专门化 std::swap 算法
(函数模板) [编辑]

[编辑] 概述

namespace std {
  enum class future_errc {
    broken_promise = /* implementation-defined */,
    future_already_retrieved = /* implementation-defined */,
    promise_already_satisfied = /* implementation-defined */,
    no_state = /* implementation-defined */
  };
 
  enum class launch : /* unspecified */ {
    async = /* unspecified */,
    deferred = /* unspecified */,
    /* implementation-defined */
  };
 
  enum class future_status {
    ready,
    timeout,
    deferred
  };
 
  template<> struct is_error_code_enum<future_errc> : public true_type { };
  error_code make_error_code(future_errc e) noexcept;
  error_condition make_error_condition(future_errc e) noexcept;
 
  const error_category& future_category() noexcept;
 
  class future_error;
 
  template<class R> class promise;
  template<class R> class promise<R&>;
  template<> class promise<void>;
 
  template<class R>
    void swap(promise<R>& x, promise<R>& y) noexcept;
 
  template<class R, class Alloc>
    struct uses_allocator<promise<R>, Alloc>;
 
  template<class R> class future;
  template<class R> class future<R&>;
  template<> class future<void>;
 
  template<class R> class shared_future;
  template<class R> class shared_future<R&>;
  template<> class shared_future<void>;
 
  template<class> class packaged_task;  // not defined
  template<class R, class... ArgTypes>
    class packaged_task<R(ArgTypes...)>;
 
  template<class R, class... ArgTypes>
    void swap(packaged_task<R(ArgTypes...)>&, packaged_task<R(ArgTypes...)>&) noexcept;
 
  template<class F, class... Args>
    future<invoke_result_t<decay_t<F>, decay_t<Args>...>>
      async(F&& f, Args&&... args);
  template<class F, class... Args>
    future<invoke_result_t<decay_t<F>, decay_t<Args>...>>
      async(launch policy, F&& f, Args&&... args);
}

[编辑] 类 std::future_error

namespace std {
  class future_error : public logic_error {
  public:
    explicit future_error(future_errc e);
 
    const error_code& code() const noexcept;
    const char*       what() const noexcept;
 
  private:
    error_code ec_;             // exposition only
  };
}

[编辑] 类模板 std::promise

namespace std {
  template<class R>
  class promise {
  public:
    promise();
    template<class Allocator>
      promise(allocator_arg_t, const Allocator& a);
    promise(promise&& rhs) noexcept;
    promise(const promise&) = delete;
    ~promise();
 
    // assignment
    promise& operator=(promise&& rhs) noexcept;
    promise& operator=(const promise&) = delete;
    void swap(promise& other) noexcept;
 
    // retrieving the result
    future<R> get_future();
 
    // setting the result
    void set_value(/* see description */);
    void set_exception(exception_ptr p);
 
    // setting the result with deferred notification
    void set_value_at_thread_exit(/* see description */);
    void set_exception_at_thread_exit(exception_ptr p);
  };
 
  template<class R>
    void swap(promise<R>& x, promise<R>& y) noexcept;
 
  template<class R, class Alloc>
    struct uses_allocator<promise<R>, Alloc>;
}

[编辑] 类模板 std::future

namespace std {
  template<class R>
  class future {
  public:
    future() noexcept;
    future(future&&) noexcept;
    future(const future&) = delete;
    ~future();
    future& operator=(const future&) = delete;
    future& operator=(future&&) noexcept;
    shared_future<R> share() noexcept;
 
    // retrieving the value
    /* see description */ get();
 
    // functions to check state
    bool valid() const noexcept;
 
    void wait() const;
    template<class Rep, class Period>
      future_status wait_for(const chrono::duration<Rep, Period>& rel_time) const;
    template<class Clock, class Duration>
      future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
  };
}

[编辑] 类模板 std::shared_future

namespace std {
  template<class R>
  class shared_future {
  public:
    shared_future() noexcept;
    shared_future(const shared_future& rhs) noexcept;
    shared_future(future<R>&&) noexcept;
    shared_future(shared_future&& rhs) noexcept;
    ~shared_future();
    shared_future& operator=(const shared_future& rhs) noexcept;
    shared_future& operator=(shared_future&& rhs) noexcept;
 
    // retrieving the value
    /* see description */ get() const;
 
    // functions to check state
    bool valid() const noexcept;
 
    void wait() const;
    template<class Rep, class Period>
      future_status wait_for(const chrono::duration<Rep, Period>& rel_time) const;
    template<class Clock, class Duration>
      future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
  };
}

[编辑] 类模板 std::packaged_task

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 description */>;
 
  template<class R, class... ArgTypes>
    void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgTypes...)>& y) noexcept;
}
取自 "https://cppreference.cn/mwiki/index.php?title=cpp/header/future&oldid=163996"