CKTIS / C++
std::packaged_task — een aanroepbare taak met een future-resultaat
std::packaged_task verpakt een aanroepbaar object en slaat het resultaat of de uitzondering op in gedeelde toestand. std::packaged_task::get_future geeft een std::future om dat resultaat op te halen; de taak start zelf geen nieuwe thread.
Versie: C++23; repository compiler flag, production runtime not attested
Syntax
#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...)> uit <future> slaat een aanroepbaar object met de opgegeven signatuur op. R geeft het resultaattype aan en Args... de argumenttypen. Het object kan worden verplaatst, maar niet gekopieerd. Het maken van een taak start noch de berekening, noch een thread: task(args...) voert de functie uit in de aanroepende thread.
std::packaged_task::get_future() retourneert een std::future<R> dat aan dezelfde gedeelde toestand is gekoppeld. Het voert de taak niet uit en mag per gedeelde toestand maar één keer worden aangeroepen. Een volgende aanroep veroorzaakt std::future_error met std::future_errc::future_already_retrieved; als er geen toestand is, bijvoorbeeld na standaardconstructie of nadat het object is verplaatst, ontstaat std::future_errc::no_state.
Bij het aanroepen van de taak wordt de geretourneerde waarde of de uitzondering van de functie opgeslagen en wordt de toestand gereed. result.get() wacht tot de toestand gereed is en haalt de waarde op of werpt de opgeslagen uitzondering opnieuw; daarna retourneert result.valid() false. In het voorbeeld is de taak klaar voordat get() wordt aangeroepen, dus wachten is niet nodig. get() aanroepen voordat de taak in dezelfde thread wordt uitgevoerd, zou verdere uitvoering blokkeren.
De taak opnieuw aanroepen zonder reset() veroorzaakt std::future_error met std::future_errc::promise_already_satisfied. reset() maakt een nieuwe toestand voor een volgende uitvoering. De taak kan opnieuw worden aangeroepen zonder get_future() aan te roepen; een nieuwe std::future<R> is alleen nodig om het resultaat via die future op te halen. Als een taak wordt vernietigd terwijl de toestand nog niet gereed is, wordt std::future_errc::broken_promise daarin opgeslagen. De ontvanger kan die via get() ontvangen.
Voorbeelden
#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';
}
Resultaat
42
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.