shared_future, classe

Décrit un objet de retour asynchrone. Contrairement à un objet future, un fournisseur asynchrone peut être associé à un nombre quelconque d’objets shared_future.

Syntaxe

template <class Ty>
class shared_future;

Notes

N’appelez aucune méthode autre que valid, operator=et le destructeur sur un shared_future objet vide.

shared_future les objets ne sont pas synchronisés. L’appel de méthodes sur le même objet par plusieurs threads provoque une concurrence critique des données qui a des résultats imprévisibles.

Membres

Constructeurs publics

Nom	Description
shared_future	Construit un objet shared_future.

Méthodes publiques

Nom	Description
get	Récupère le résultat qui est stocké dans l’état asynchrone associé.
Valide	Spécifie si l’objet n’est pas vide.
Attendre	Bloque le thread actuel jusqu’à ce que l’état asynchrone associé soit prêt.
wait_for	Bloque le thread actuel jusqu’à ce que l’état asynchrone associé soit prêt ou que le délai spécifié soit écoulé.
wait_until	Bloque le thread actuel jusqu’à ce que l’état asynchrone associé soit prêt ou jusqu’à un point spécifié dans le temps.

Opérateurs publics

Nom	Description
shared_future::operator=	Assigne un nouvel état asynchrone associé.

Spécifications

Header :<future>

Espace de noms : std

shared_future ::get

Récupère le résultat qui est stocké dans l’état asynchrone associé.

const Ty& get() const;

Ty& get() const;

void get() const;

Notes

Si le résultat est une exception, la méthode la lève de nouveau. Sinon, le résultat est retourné.

Avant de récupérer le résultat, cette méthode bloque le thread actuel jusqu’à ce que l’état asynchrone associé soit prêt.

Pour la spécialisation partielle shared_future<Ty&>, la valeur stockée est une référence à l’objet qui a été passé au fournisseur asynchrone comme valeur de retour.

Comme il n’y a pas de valeur stockée pour la spécialisation shared_future<void>, la méthode retourne void.

shared_future::operator=

Transfère un état asynchrone associé à partir d’un objet spécifié.

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

Paramètres

Right
Objet shared_future.

Valeur de retour

*this

Notes

Pour le premier opérateur, Right n’a plus d’état asynchrone associé après l’opération.

Pour la deuxième méthode, Right conserve son état asynchrone associé.

shared_future::shared_future, constructeur

Construit un objet shared_future.

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

Paramètres

Right
Objet future ou shared_future.

Notes

Le premier constructeur construit un objet shared_future sans état asynchrone associé.

Les deuxième et troisième constructeurs construisent un shared_future objet et transfèrent l’état asynchrone associé à partir de Right. Right n’a plus d’état asynchrone associé.

Le quatrième constructeur construit un shared_future objet qui a le même état asynchrone associé que Right.

shared_future ::valid

Spécifie si l’objet a un état asynchrone associé.

bool valid() noexcept;

Valeur de retour

true si l'objet possède un état asynchrone associé ; sinon, false.

shared_future ::wait

Bloque le thread actuel jusqu’à ce que l’état asynchrone associé soit prêt.

void wait() const;

Notes

Un état asynchrone associé est prêt uniquement si son fournisseur asynchrone a stocké une valeur de retour ou une exception.

shared_future ::wait_for

Bloque le thread actuel jusqu’à ce que l’état asynchrone associé soit prêt ou que le temps spécifié soit écoulé.

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

Paramètres

Rel_time
Objet chrono::duration qui spécifie un intervalle de temps maximal pour le blocage du thread.

Valeur de retour

future_status qui indique la raison du retour.

Notes

Un état asynchrone associé est prêt uniquement si son fournisseur asynchrone a stocké une valeur de retour ou une exception.

shared_future ::wait_until

Bloque le thread actuel jusqu’à ce que l’état asynchrone associé soit prêt ou jusqu’à un point spécifié dans le temps.

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

Paramètres

Abs_time
Objet chrono::time_point qui spécifie un point dans le temps après lequel le thread peut être débloqué.

Valeur de retour

future_status qui indique la raison du retour.

Notes

Un état asynchrone associé est prêt uniquement si son fournisseur asynchrone a stocké une valeur de retour ou une exception.

Voir aussi

Informations de référence sur les fichiers d’en-tête
<future>