RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://cplusplus.com/shared_future below:

class template

std::shared_future

template <class T>  shared_future;template <class R&> shared_future<R&>;   // specialization : T is a reference type (R&)template <>         shared_future<void>; // specialization : T is void

Shared future

A shared_future object behaves like a future object, except that it can be copied, and that more than one shared_future can share ownership over their end of a shared state. They also allow the value in the shared state to be retrieved multiple times once ready.

shared_future objects can be implicitly converted from future objects (see its constructor), or explicitly obtained by calling future::share. In both cases, the future object from which it is obtained transfers its association with the shared state to the shared_future and becomes itself non-valid.

The lifetime of the shared state lasts at least until the last object with which it is associated is destroyed. Retrieving the value from a shared_future (with member get) does not release its ownership over the shared state (unlike with futures). Therefore, if associated to shared_future objects, the shared state can survive the object from which it was obtained in the first place (if any).

Member functions

(constructor): Construct shared_future (public member function)

(destructor): Destroy shared_future (public member function)

operator=: Assign shared future (public member function)

get: Get value (public member function)

valid: Check for valid shared state (public member function)

wait: Wait for ready (public member function)

wait_for: Wait for ready during time span (public member function)

wait_until: Wait for ready until time point (public member function)

Template specializations Two specific shared_future specializations are declared in <future>:

1
2

template <class R&> shared_future<R&>;   // specialization : T is a reference type (R&)
template <>         shared_future<void>; // specialization : T is void

They operate in the same way as the unspecialized template, except for the return value of their shared_future::get member function.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4