Namespaces
Variants

std::packaged_task<R(Args...)>:: packaged_task

From cppreference.net
C++
Concurrency support library
Threads
(C++11)
(C++20)
(C++17) (C++17)
this_thread namespace
(C++11)
(C++11)
Cooperative cancellation
Mutual exclusion
Generic lock management
Condition variables
(C++11)
(C++11)
(C++11)
(C++11)
Semaphores
(C++20) (C++20)
Latches and Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Safe reclamation
Hazard pointers
(C++26)
(C++26)
(C++26)
Atomic types
(C++11)
(C++20)
(C++11)
Initialization of atomic types
(C++11) (deprecated in C++20)
(C++11) (deprecated in C++20)
(C++11)
Memory ordering
(C++11)
(C++11) (deprecated in C++26)
(C++11)
(C++11)
Free functions for atomic operations
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11) (C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++26) (C++26)
(C++26) (C++26)
(C++11)
(C++20) (C++20)
(C++20)
(C++20)
Free functions for atomic flags
(C++11) (C++11)
(C++11) (C++11)
(C++20) (C++20)
(C++20) (C++20)
(C++20)
(C++20)
std::packaged_task
packaged_task ( ) noexcept ;
(1) (depuis C++11)
template < class F >
explicit packaged_task ( F && f ) ;
(2) (depuis C++11)
template < class F, class Allocator >
explicit packaged_task ( std:: allocator_arg_t , const Allocator & a, F && f ) ;
(3) (depuis C++11)
(jusqu'à C++17)
packaged_task ( const packaged_task & ) = delete ;
(4) (depuis C++11)
packaged_task ( packaged_task && rhs ) noexcept ;
(5) (depuis C++11)

Construit un nouvel objet std::packaged_task .

1) Construit un objet std::packaged_task sans tâche et sans état partagé.
2,3) Construit un objet std::packaged_task avec une tâche stockée de type std:: decay < F > :: type et un état partagé. La tâche stockée est initialisée avec std:: forward < F > ( f ) .

Ces surcharges participent à la résolution de surcharge seulement si std:: decay < F > :: type n'est pas du même type que std:: packaged_task < R ( Args... ) > .

Soient t1 , t2 , ..., tN des valeurs des types correspondants dans Args , si INVOKE<R> ( f, t1, t2, ..., tN ) n'est pas une expression valide, le programme est mal formé.

(jusqu'à C++20)

Cette surcharge participe à la résolution de surcharge seulement si std:: remove_cvref_t < F > n'est pas du même type que std:: packaged_task < R ( Args... ) > .

Si std:: is_invocable_r_v < R, std:: decay_t < F > & , Args... > est false , le programme est mal formé.

(depuis C++20)
3) L'allocateur a est utilisé pour allouer la mémoire nécessaire au stockage de la tâche.
4) Le constructeur de copie est supprimé, std::packaged_task est uniquement déplaçable.
5) Construit un std::packaged_task avec l'état partagé et la tâche précédemment détenus par rhs , laissant rhs sans état partagé et avec une tâche déplacée.

Table des matières

Paramètres

f - la cible appelable à exécuter
a - l'allocateur à utiliser pour stocker la tâche
rhs - le std::packaged_task à déplacer

Exceptions

2) Toute exception levée par le constructeur de copie/déplacement de f et éventuellement std::bad_alloc si l'allocation échoue.
3) Toute exception levée par le constructeur de copie/déplacement de f et par la fonction allocate de l'allocateur en cas d'échec d'allocation de mémoire.

Exemple

Exécuter ce code 
#include <future>
#include <iostream>
#include <thread>
int fib(int n)
{
    if (n < 3)
        return 1;
    else
        return fib(n - 1) + fib(n - 2);
}
int main()
{
    std::packaged_task<int(int)> fib_task(&fib); 
    std::cout << "Démarrage de la tâche\n";
    auto result = fib_task.get_future();
    std::thread t(std::move(fib_task), 42);
    std::cout << "En attente de la fin de la tâche..." << std::endl;
    std::cout << result.get() << '\n';
    std::cout << "Tâche terminée\n";
    t.join();
}

Sortie : 

Démarrage de la tâche
En attente de la fin de la tâche...
267914296
Tâche terminée

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Applicable à Comportement publié Comportement corrigé
LWG 2067 C++11 le type de paramètre du constructeur de copie était packaged_task& ajout de const
LWG 2097 C++11 pour les surcharges (2,3) , F pouvait être std::packaged_task<R(Args...)> F est contraint
LWG 4154 C++11 les surcharges (2,3) ne prenaient pas en compte la décomposition prise en compte de la décomposition