shared_future-Klasse

Beschreibt ein asynchrones Rückgabeobjekt. Im Gegensatz zu einem zukünftigen Objekt, kann ein asynchroner Anbieter beliebig vielen shared_future-Objekten zugeordnet werden.

Syntax

template <class Ty>
class shared_future;

Hinweise

Rufen Sie keine anderen Methoden als valid, operator=und den Destruktor für ein shared_future Objekt auf, das leer ist.

shared_future Objekte werden nicht synchronisiert. Aufrufen von Methoden für das gleiche Objekt von mehreren Threads führt zu einem Datenrace mit unvorhersehbaren Ergebnissen.

Member

Öffentliche Konstruktoren

Name	Beschreibung
shared_future	Erstellt ein shared_future-Objekt.

Öffentliche Methoden

Name	Beschreibung
get	Ruft das Ergebnis ab, das im zugeordneten asynchronen Zustand gespeichert ist.
Gültig	Gibt an, ob das Objekt nicht leer ist.
Warte	Blockiert den aktuellen Thread, bis der zugeordnete asynchrone Zustandbereit ist.
wait_for	Blockiert, bis der zugeordnete asynchrone Zustand bereit ist, oder bis die angegebene Zeit verstrichen ist.
wait_until	Blockiert, bis der zugeordnete asynchrone Zustand bereit ist, oder bis ein angegebener Zeitpunkt erreicht ist.

Öffentliche Operatoren

Name	Beschreibung
shared_future::operator=	Weist einen neuen zugeordneten asynchronen Zustand zu.

Anforderungen

Header:<future>

Namespace: std

shared_future::get

Ruft das Ergebnis ab, das im zugeordneten asynchronen Zustand gespeichert ist.

const Ty& get() const;

Ty& get() const;

void get() const;

Hinweise

Wenn das Ergebnis eine Ausnahme ist, wird es erneut von der Methode ausgelöst. Andernfalls wird das Ergebnis zurückgegeben.

Bevor sie das Ergebnis abruf, blockiert diese Methode den aktuellen Thread, bis der zugeordnete asynchrone Zustand bereit ist.

Für die Teilspezialisierung shared_future<Ty&> ist der gespeicherte Wert praktisch ein Verweis auf das Objekt, das dem asynchronen Anbieter als Rückgabewert übergeben wurde.

Weil für die Spezialisierung shared_future<void> kein gespeicherten Wert existiert, gibt die Methode void zurück.

shared_future::operator=

Überträgt einen zugeordneten asynchronen Zustand aus einem angegebenen Objekt.

shared_future& operator=(shared_future&& Right) noexcept;
shared_future& operator=(const shared_future& Right);

Parameter

Right
Ein shared_future-Objekt.

Rückgabewert

*this

Bemerkungen

Für den ersten Operator verfügt Right nach dem Vorgang nicht mehr über einen zugeordneten asynchronen Zustand.

Für die zweite Methode behält Right Standard den zugeordneten asynchronen Zustand bei.

shared_future::shared_future-Konstruktor

Erstellt ein shared_future-Objekt.

shared_future() noexcept;
shared_future(future<Ty>&& Right) noexcept;
shared_future(shared_future&& Right) noexcept;
shared_future(const shared_future& Right);

Parameter

Right
Ein zukünftiges oder shared_future-Objekt.

Hinweise

Der erste Konstruktor erstellt ein shared_future-Objekt, das über keinen zugeordneten asynchronen Zustand verfügt.

Die zweiten und dritten Konstruktoren erstellen ein shared_future Objekt und übertragen den zugeordneten asynchronen Zustand von Rechts. Rechts verfügt nicht mehr über einen zugeordneten asynchronen Zustand.

Der vierte Konstruktor erstellt ein shared_future Objekt, das denselben asynchronen Zustand wie Right aufweist.

shared_future::valid

Gibt an, ob das Objekt einen zugeordneten asynchronen Zustand hat.

bool valid() noexcept;

Rückgabewert

true, wenn das Objekt einen zugeordneten asynchronen Zustand hat; andernfalls false.

shared_future::wait

Blockiert den aktuellen Thread, bis der zugeordnete asynchrone Zustandbereit ist.

void wait() const;

Hinweise

Ein zugeordneter asynchroner Zustand ist nur dann bereit, wenn sein asynchroner Anbieter einen Rückgabewert oder eine Ausnahme gespeichert hat.

shared_future::wait_for

Blockiert den aktuellen Thread, bis der zugeordnete asynchrone Zustand bereit oder eine angegebene Zeit verstrichen ist.

template <class Rep, class Period>
future_status wait_for(
    const chrono::duration<Rep, Period>& Rel_time) const;

Parameter

Rel_time
Ein chrono::duration-Objekt, das ein maximales Zeitintervall angibt, das der Thread blockiert.

Rückgabewert

Ein future_status, das den Grund für die Rückgabe angibt.

Hinweise

Ein zugeordneter asynchroner Zustand ist nur dann bereit, wenn sein asynchroner Anbieter einen Rückgabewert oder eine Ausnahme gespeichert hat.

shared_future::wait_until

Blockiert den aktuelle Thread, bis der zugeordnete asynchrone Zustand bereit oder ein angegebener Zeitpunkt verstrichen ist.

template <class Clock, class Duration>
future_status wait_until(
    const chrono::time_point<Clock, Duration>& Abs_time) const;

Parameter

Abs_time
Ein chrono::time_point-Objekt, das eine Zeit angibt, nach der der Thread die Blockierung aufheben kann.

Rückgabewert

Ein future_status, das den Grund für die Rückgabe angibt.

Hinweise

Ein zugeordneter asynchroner Zustand ist nur dann bereit, wenn sein asynchroner Anbieter einen Rückgabewert oder eine Ausnahme gespeichert hat.

Siehe auch

Headerdateienreferenz
<future>