Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::packaged_task — un’attività invocabile con risultato future

std::packaged_task racchiude un oggetto invocabile e ne memorizza il risultato o l’eccezione nello stato condiviso. std::packaged_task::get_future fornisce uno std::future per recuperare il risultato; l’attività non avvia da sola un nuovo thread.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

#include <future>
std::packaged_task<R(Args...)> task(callable);
std::future<R> result = task.get_future();
task(args...);
result.get();

std::packaged_task<R(Args...)>, dichiarato in <future>, memorizza un oggetto invocabile con la firma specificata. R indica il tipo del risultato e Args... i tipi degli argomenti. L’oggetto può essere spostato, ma non copiato. La creazione dell’attività non avvia né il calcolo né un thread: task(args...) esegue la funzione nel thread chiamante.

std::packaged_task::get_future() restituisce uno std::future<R> collegato allo stesso stato condiviso. Non esegue l’attività e può essere chiamato una sola volta per ciascuno stato condiviso. Una chiamata successiva genera std::future_error con std::future_errc::future_already_retrieved; l’assenza di uno stato, per esempio dopo la costruzione predefinita o dopo aver spostato l’oggetto, comporta std::future_errc::no_state.

Quando si invoca l’attività, il valore restituito dalla funzione o la sua eccezione vengono memorizzati e lo stato diventa pronto. result.get() attende che sia pronto e recupera il valore oppure rilancia l’eccezione memorizzata; in seguito, result.valid() restituisce false. Nell’esempio l’attività termina prima di get(), quindi non è necessario attendere. Chiamare get() prima di eseguire l’attività nello stesso thread bloccherebbe il proseguimento dell’esecuzione.

Invocare di nuovo l’attività senza reset() genera std::future_error con std::future_errc::promise_already_satisfied. reset() crea un nuovo stato per un’altra esecuzione. Si può invocare di nuovo l’attività senza chiamare get_future(); un nuovo std::future<R> serve solo se si vuole recuperare il risultato tramite esso. Se viene distrutta un’attività il cui stato non è pronto, nello stato viene memorizzato std::future_errc::broken_promise, che il destinatario può ricevere tramite get().

Esempi

#include <future>
#include <iostream>

int main() {
    std::packaged_task<int(int, int)> task(
        [](int a, int b) { return a + b; });
    std::future<int> result = task.get_future();

    task(20, 22);
    std::cout << result.get() << '\n';
}

Risultato

42

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti