public member function

std::promise::set_value_at_thread_exit

generic template (1)	void set_value_at_thread_exit (const T& val); void set_value_at_thread_exit (T&& val);
specializations (2)	void promise<R&>::set_value_at_thread_exit (R& val); // when T is a reference type (R&) void promise<void>::set_value_at_thread_exit (void); // when T is void

generic template (1)

void set_value_at_thread_exit (const T& val);
void set_value_at_thread_exit (T&& val);

specializations (2)

void promise<R&>::set_value_at_thread_exit (R& val);     // when T is a reference type (R&)
void promise<void>::set_value_at_thread_exit (void);     // when T is void

Set value at thread exit

Stores val as the value in the shared state without making it ready immediately. Instead, it will be made ready automatically at thread exit, once all objects of thread storage duration have been destroyed.

If a future object that is associated to the same shared state is waiting on a call to future::get, it stays blocked until the thread ends. Once the thread ends, it unblocks and returns val.

Notice that calling this function already sets the value in the shared state, and any call that attempts to modify this value between this call and the end of the thread will throw future_error with promise_already_satisfied as error condition.

Parameters

val: The value for the shared state.

Return value

none

Data races

The promise object is modified.
The shared state is modified as an atomic operation (causing no data races), with synchronization happening at thread end.

Exception safety

Basic guarantee: if an exception is thrown, the promise object is in a valid state.

This member function throws an exception on the following conditions:

exception type	error condition	description
`future_error`	`future_errc::no_state`	The object has no shared state (it was moved-from)
`future_error`	`future_errc::promise_already_satisfied`	The shared state already has a stored value or exception

This member function also throws if the constructor selected to copy/move val throws (for (1)) and -depending on the library implementation- may also throw to report other situations.

promise::promise
promise::~promise
member functions:
non-member overloads:
- swap (promise)
non-member specializations:
- uses_allocator<promise>

std::promise::set_value_at_thread_exit

Parameters

Return value

Data races

Exception safety

See also

C++

Reference

C library:

Containers:

Input/Output:

Multi-threading:

Other:

<future>

classes:

enum classes:

functions:

promise

member functions:

non-member overloads:

non-member specializations: