MENU
Edit
In Place Editing Advanced Editing

future

This header is part of the thread support library.

Classes

(C++11)
 stores a value for asynchronous retrieval
(class template)
(C++11)
 packages a function to store its return value for asynchronous retrieval
(class template)
(C++11)
 waits for a value that is set asynchronously
(class template)
(C++11)
 waits for a value (possibly referenced by other futures) that is set asynchronously
(class template)
(C++11)
 specifies the launch policy for std::async
(enum)
(C++11)
 specifies the results of timed waits performed on std::future and std::shared_future
(enum)
(C++11)
 reports an error related to futures or promises
(class)
(C++11)
 identifies the future error codes
(enum)
(C++11)
 specializes the std::uses_allocator type trait
(class template specialization)
(C++11)
 specializes the std::uses_allocator type trait
(class template specialization)

Functions

(C++11)
 runs a function asynchronously (potentially in a new thread) and returns a std::future that will hold the result
(function template)
(C++11)
 identifies the future error category
(function)
(C++11)
 specializes the std::swap algorithm
(function template)
(C++11)
 specializes the std::swap algorithm
(function template)

Synopsis

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
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> : true_type {};
  
    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; // undefined
    template <class R, class... ArgTypes>
    class packaged_task<R(ArgTypes...)>;
  
    template <class R>
    void swap(packaged_task<R(ArgTypes...)>&,
              packaged_task<R(ArgTypes...)>&) noexcept;
  
    template <class R, class Alloc>
    struct uses_allocator<packaged_task<R>, Alloc> : true_type {};
  
    template <class F, class... Args>
     future<result_of_t<decay_t<F>(decay_t<Args>...)>>
     async(F&& f, Args&&... args);
  
    template <class F, class... Args>
     future<result_of_t<decay_t<F>(decay_t<Args>...)>>
     async(launch policy, F&& f, Args&&... args);
}

Class std::future_error

1
2
3
4
5
6
class future_error : public logic_error {
 public:
    future_error(error_code ec); // exposition only
    const error_code& code() const noexcept;
    const char* what() const noexcept;
};

Class std::promise

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
template <class R>
class promise {
 public:
    promise();
    template <class Allocator>
    promise(allocator_arg_t, const Allocator& a);
    promise(promise&& rhs) noexcept;
    promise(const promise& rhs) = delete;
    ~promise();
  
    // assignment
    promise& operator=(promise&& rhs) noexcept;
    promise& operator=(const promise& rhs) = delete;
    void swap(promise& other) noexcept;
  
    // retrieving the result
    future<R> get_future();
  
    // setting the result
    void set_value(see below );
    void set_exception(exception_ptr p);
  
    // setting the result with deferred notification
    void set_value_at_thread_exit(const R& r);
    void set_value_at_thread_exit(see below );
    void set_exception_at_thread_exit(exception_ptr p);
};

Class std::future

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
template <class R>
class future {
 public:
    future() noexcept;
    future(future &&) noexcept;
    future(const future& rhs) = delete;
    ~future();
    future& operator=(const future& rhs) = delete;
    future& operator=(future&&) noexcept;
    shared_future<R> share();
  
    // retrieving the value
    see below 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;
};

Class std::shared_future

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
template <class R>
class shared_future {
 public:
    shared_future() noexcept;
    shared_future(const shared_future& rhs);
    shared_future(future<R>&&) noexcept;
    shared_future(shared_future&& rhs) noexcept;
    ~shared_future();
    shared_future& operator=(const shared_future& rhs);
    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;
};

Class std::packaged_task

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
template<class> class packaged_task; // undefined
  
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();
};
doc_CPP
doc_CPP
2025-01-10 15:47:30
Comments
Leave a Comment

Please login to continue.