Namespaces
Variants

std:: 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)
packaged_task
(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
Défini dans l'en-tête <future>
template < class >
class packaged_task ;
(1) (depuis C++11)
(non défini)
template < class R, class ... ArgTypes >
class packaged_task < R ( ArgTypes... ) > ;
(2) (depuis C++11)

Le modèle de classe std::packaged_task encapsule toute cible Callable (fonction, expression lambda, expression bind, ou autre objet fonction) afin qu'elle puisse être invoquée de manière asynchrone. Sa valeur de retour ou l'exception levée est stockée dans un état partagé accessible via des objets std::future .

Tout comme std::function , std::packaged_task est un conteneur polymorphe sensible aux allocateurs : la cible appelable stockée peut être allouée sur le tas ou avec un allocateur fourni.

(jusqu'à C++17)

Table des matières

Fonctions membres

construit l'objet de tâche
(fonction membre publique)
détruit l'objet de tâche
(fonction membre publique)
déplace l'objet de tâche
(fonction membre publique)
vérifie si l'objet de tâche a une fonction valide
(fonction membre publique)
échange deux objets de tâche
(fonction membre publique)
Obtention du résultat
retourne un std::future associé au résultat promis
(fonction membre publique)
Exécution
exécute la fonction
(fonction membre publique)
exécute la fonction en s'assurant que le résultat est prêt uniquement lorsque le thread actuel se termine
(fonction membre publique)
réinitialise l'état en abandonnant tout résultat stocké des exécutions précédentes
(fonction membre publique)

Fonctions non membres

(C++11)
spécialise l'algorithme std::swap
(modèle de fonction)

Classes d'assistance

(C++11) (jusqu'en C++17)
spécialise le std::uses_allocator trait de type
(spécialisation de modèle de classe)

Guides de déduction (depuis C++17)

Exemple

Exécuter ce code 
#include <cmath>
#include <functional>
#include <future>
#include <iostream>
#include <thread>
// unique function to avoid disambiguating the std::pow overload set
int f(int x, int y) { return std::pow(x, y); }
void task_lambda()
{
    std::packaged_task<int(int, int)> task([](int a, int b)
    {
        return std::pow(a, b); 
    });
    std::future<int> result = task.get_future();
    task(2, 9);
    std::cout << "task_lambda:\t" << result.get() << '\n';
}
void task_bind()
{
    std::packaged_task<int()> task(std::bind(f, 2, 11));
    std::future<int> result = task.get_future();
    task();
    std::cout << "task_bind:\t" << result.get() << '\n';
}
void task_thread()
{
    std::packaged_task<int(int, int)> task(f);
    std::future<int> result = task.get_future();
    std::thread task_td(std::move(task), 2, 10);
    task_td.join();
    std::cout << "task_thread:\t" << result.get() << '\n';
}
int main()
{
    task_lambda();
    task_bind();
    task_thread();
}

Sortie : 

task_lambda: 512
task_bind:   2048
task_thread: 1024

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 Appliqué à Comportement publié Comportement corrigé
LWG 3117 C++17 les guides de déduction pour packaged_task étaient manquants ajoutés

Voir aussi

(C++11)
attend une valeur définie de manière asynchrone
(modèle de classe)