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
Definido en el encabezado <future>
template < class >
class packaged_task ;
(1) (desde C++11)
(no definido)
template < class R, class ... ArgTypes >
class packaged_task < R ( ArgTypes... ) > ;
(2) (desde C++11)

La plantilla de clase std::packaged_task envuelve cualquier Callable objetivo (función, expresión lambda, expresión bind u otro objeto función) para que pueda ser invocada asincrónicamente. Su valor de retorno o excepción lanzada se almacena en un estado compartido al que se puede acceder mediante objetos std::future .

Al igual que std::function , std::packaged_task es un contenedor polimórfico y consciente del asignador: el destino invocable almacenado puede asignarse en el montón o con un asignador proporcionado.

(until C++17)

Contenidos

Funciones miembro

construye el objeto de tarea
(función miembro pública)
destruye el objeto de tarea
(función miembro pública)
mueve el objeto de tarea
(función miembro pública)
verifica si el objeto de tarea tiene una función válida
(función miembro pública)
intercambia dos objetos de tarea
(función miembro pública)
Obtención del resultado
devuelve un std::future asociado con el resultado prometido
(función miembro pública)
Ejecución
ejecuta la función
(función miembro pública)
ejecuta la función asegurando que el resultado esté listo solo cuando el hilo actual finalice
(función miembro pública)
restablece el estado abandonando cualquier resultado almacenado de ejecuciones anteriores
(función miembro pública)

Funciones no miembro

(C++11)
especializa el algoritmo std::swap
(plantilla de función)

Clases auxiliares

(C++11) (until C++17)
especializa el trait de tipo std::uses_allocator
(especialización de plantilla de clase)

Guías de deducción (desde C++17)

Ejemplo

Ejecutar este código 
#include <cmath>
#include <functional>
#include <future>
#include <iostream>
#include <thread>
// función única para evitar ambigüedad en el conjunto de sobrecargas de std::pow
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();
}

Salida: 

task_lambda: 512
task_bind:   2048
task_thread: 1024

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Se aplica a Comportamiento publicado Comportamiento correcto
LWG 3117 C++17 las guías de deducción para packaged_task faltaban añadidas

Véase también

(C++11)
espera un valor que se establece de forma asíncrona
(plantilla de clase)