Namespaces
Variants

std::experimental:: when_all

From cppreference.net
C++
Experimental
Extensions for concurrency
Défini dans l'en-tête <experimental/future>
template < class InputIt >

auto when_all ( InputIt first, InputIt last )

- > future < std:: vector < typename std:: iterator_traits < InputIt > :: value_type >> ;
(1) (concurrency TS)
template < class ... Futures >

auto when_all ( Futures && ... futures )

- > future < std:: tuple < std:: decay_t < Futures > ... >> ;
(2) (concurrency TS)

Créez un objet future qui devient prêt lorsque toutes les future s et shared_future s d'entrée sont prêtes. Le comportement est indéfini si une future ou shared_future d'entrée est invalide.

En particulier, soit Sequence un std:: vector < typename std:: iterator_traits < InputIt > :: value_type > pour (1) et std:: tuple < std:: decay_t < Futures > ... > pour (2) . Ce modèle de fonction crée un état partagé contenant Sequence et retourne un futur référençant cet état partagé. Chaque future d'entrée est déplacé dans l'objet correspondant de la Sequence dans l'état partagé, et chaque shared_future d'entrée est copié dans l'objet correspondant de la Sequence dans l'état partagé. L'ordre des objets dans la Sequence correspond à l'ordre des arguments.

1) Cette fonction ne participe pas à la résolution de surcharge sauf si InputIt 's value type (c'est-à-dire, typename std:: iterator_traits < InputIt > :: value_type ) est un std::experimental::future ou un std::experimental::shared_future .
2) Cette fonction ne participe pas à la résolution de surcharge sauf si chaque argument est soit un std::experimental::shared_future (éventuellement qualifié cv), soit un std::experimental::future non qualifié cv. (Formellement, pour chaque type Fn dans Futures , soit std:: remove_reference_t < Fn > est std:: experimental :: future < Rn > , soit std:: decay_t < Fn > est std:: experimental :: shared_future < Rn > .)

Après cet appel, chaque future d'entrée n'est plus valide ; chaque shared_future d'entrée reste valide.

Valeur de retour

Un future faisant référence à l'état partagé créé par l'appel. Le futur est toujours valide ( ) , et il devient prêt lorsque tous les future s et shared_future s d'entrée de l'appel sont prêts.

1) Si la plage est vide (c'est-à-dire, first == last ), le future retourné contient un vecteur vide et est prêt immédiatement.
2) S'il n'y a aucun argument fourni, un future<std::tuple<>> est retourné et est immédiatement prêt.