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) (seit C++11)
template < class F >
explicit packaged_task ( F && f ) ;
(2) (seit C++11)
template < class F, class Allocator >
explicit packaged_task ( std:: allocator_arg_t , const Allocator & a, F && f ) ;
(3) (seit C++11)
(bis C++17)
packaged_task ( const packaged_task & ) = delete ;
(4) (seit C++11)
packaged_task ( packaged_task && rhs ) noexcept ;
(5) (seit C++11)

Konstruiert ein neues std::packaged_task -Objekt.

1) Konstruiert ein std::packaged_task -Objekt ohne Aufgabe und ohne gemeinsamen Zustand.
2,3) Konstruiert ein std::packaged_task -Objekt mit einer gespeicherten Aufgabe vom Typ std:: decay < F > :: type und einem gemeinsamen Zustand. Die gespeicherte Aufgabe wird mit std:: forward < F > ( f ) initialisiert.

Diese Überladungen nehmen nur dann an der Überladungsauflösung teil, wenn std:: decay < F > :: type nicht derselbe Typ wie std:: packaged_task < R ( Args... ) > ist.

Seien t1 , t2 , ..., tN Werte der entsprechenden Typen in Args . Wenn INVOKE<R> ( f, t1, t2, ..., tN ) kein gültiger Ausdruck ist, ist das Programm fehlerhaft.

(bis C++20)

Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn std:: remove_cvref_t < F > nicht derselbe Typ wie std:: packaged_task < R ( Args... ) > ist.

Wenn std:: is_invocable_r_v < R, std:: decay_t < F > & , Args... > false ist, ist das Programm fehlerhaft.

(seit C++20)
3) Der Allokator a wird verwendet, um den für die Speicherung der Aufgabe notwendigen Speicher zu allozieren.
4) Der Kopierkonstruktor ist gelöscht, std::packaged_task ist nur verschiebbar.
5) Konstruiert einen std::packaged_task mit dem gemeinsam genutzten Zustand und der Aufgabe, die zuvor im Besitz von rhs waren, und lässt rhs ohne gemeinsam genutzten Zustand und mit einer verschobenen Aufgabe zurück.

Inhaltsverzeichnis

Parameter

f - das aufrufbare Ziel zur Ausführung
a - der bei der Speicherung der Aufgabe zu verwendende Allokator
rhs - der std::packaged_task , von dem verschoben werden soll

Exceptions

2) Alle Ausnahmen, die vom Kopier-/Verschiebekonstruktor von f und möglicherweise std::bad_alloc geworfen werden, falls die Allokation fehlschlägt.
3) Alle Ausnahmen, die vom Kopier-/Verschiebekonstruktor von f und von der allocate -Funktion des Allokators ausgelöst werden, falls die Speicherzuweisung fehlschlägt.

Beispiel

Diesen Code ausführen 
#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 << "Starting task\n";
    auto result = fib_task.get_future();
    std::thread t(std::move(fib_task), 42);
    std::cout << "Waiting for task to finish..." << std::endl;
    std::cout << result.get() << '\n';
    std::cout << "Task complete\n";
    t.join();
}

Ausgabe: 

Starting task
Waiting for task to finish...
267914296
Task complete

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Veröffentlichtes Verhalten Korrigiertes Verhalten
LWG 2067 C++11 Der Parametertyp des Kopierkonstruktors war packaged_task& const hinzugefügt
LWG 2097 C++11 Für Überladungen (2,3) konnte F std::packaged_task<R(Args...)> sein F ist eingeschränkt
LWG 4154 C++11 Überladungen (2,3) berücksichtigten kein Decaying Decaying berücksichtigt