Namespaces
Variants

std::promise<R>:: set_value

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::promise
Haupttemplate
void set_value ( const R & value ) ;
(1) (seit C++11)
void set_value ( R && value ) ;
(2) (seit C++11)
std:: promise < R & > Spezialisierungen
void set_value ( R & value ) ;
(3) (seit C++11)
std:: promise < void > Spezialisierung
void set_value ( ) ;
(4) (seit C++11)
1-3) Speichert atomar value im gemeinsamen Zustand und macht den Zustand bereit.
4) Macht den Zustand bereit.

Die Operation verhält sich so, als ob set_value , set_exception , set_value_at_thread_exit und set_exception_at_thread_exit einen einzelnen Mutex assoziiert mit dem Promise-Objekt erwerben, während sie das Promise-Objekt aktualisieren.

Aufrufe dieser Funktion führen nicht zu Datenrennen mit Aufrufen von get_future (daher müssen sie nicht miteinander synchronisiert werden).

Inhaltsverzeichnis

Parameter

value - Wert, der im gemeinsamen Zustand gespeichert werden soll

Rückgabewert

(keine)

Exceptions

std::future_error unter den folgenden Bedingungen:

  • * this besitzt keinen gemeinsamen Zustand. Der Fehlercode wird auf no_state gesetzt.
  • Der gemeinsame Zustand speichert bereits einen Wert oder eine Exception. Der Fehlercode wird auf promise_already_satisfied gesetzt.

Zusätzlich:

1) Jede Ausnahme, die vom Konstruktor ausgelöst wird, der zum Kopieren eines Objekts vom Typ R ausgewählt wurde.
2) Jede Ausnahme, die vom Konstruktor ausgelöst wird, der ausgewählt wurde, um ein Objekt vom Typ R zu verschieben.

Beispiel

Dieses Beispiel zeigt, wie std:: promise < void > als Signale zwischen Threads verwendet werden kann.

Code ausführen 
#include <algorithm>
#include <cctype>
#include <chrono>
#include <future>
#include <iostream>
#include <iterator>
#include <sstream>
#include <thread>
#include <vector>
using namespace std::chrono_literals;
int main()
{
    std::istringstream iss_numbers{"3 4 1 42 23 -23 93 2 -289 93"};
    std::istringstream iss_letters{" a 23 b,e a2 k k?a;si,ksa c"};
    std::vector<int> numbers;
    std::vector<char> letters;
    std::promise<void> numbers_promise, letters_promise;
    auto numbers_ready = numbers_promise.get_future();
    auto letter_ready = letters_promise.get_future();
    std::thread value_reader([&]
    {
        // I/O-Operationen
        std::copy(std::istream_iterator<int>{iss_numbers},
                  std::istream_iterator<int>{},
                  std::back_inserter(numbers));
        // Benachrichtigung für Zahlen
        numbers_promise.set_value();
        std::copy_if(std::istreambuf_iterator<char>{iss_letters},
                     std::istreambuf_iterator<char>{},
                     std::back_inserter(letters),
                     ::isalpha);
        // Benachrichtigung für Buchstaben
        letters_promise.set_value();
    });
    numbers_ready.wait();
    std::sort(numbers.begin(), numbers.end());
    if (letter_ready.wait_for(1s) == std::future_status::timeout)
    {
        // Zahlen ausgeben, während Buchstaben gelesen werden
        for (int num : numbers)
            std::cout << num << ' ';
        numbers.clear(); // Zahlen wurden bereits ausgegeben
    }
    letter_ready.wait();
    std::sort(letters.begin(), letters.end());
    // macht nichts, wenn Zahlen bereits ausgegeben wurden
    for (int num : numbers)
        std::cout << num << ' ';
    std::cout << '\n';
    for (char let : letters)
        std::cout << let << ' ';
    std::cout << '\n';
    value_reader.join();
}

Ausgabe: 

-289 -23 1 2 3 4 23 42 93 93 
a a a a b c e i k k k s s

Fehlerberichte

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

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 2098 C++11 Überladungen (1,2) konnten nur die
Ausnahmen werfen, die vom Kopier-/Verschiebe-
Konstruktor von R geworfen werden 		sie können die Ausnahmen werfen,
die vom tatsächlich ausgewählten
Konstruktor zum Kopieren/Verschieben
eines Objekts vom Typ R geworfen werden

Siehe auch

setzt das Ergebnis auf einen bestimmten Wert, liefert die Benachrichtigung jedoch erst beim Thread-Ende
(öffentliche Elementfunktion)
setzt das Ergebnis, um eine Ausnahme anzuzeigen
(öffentliche Elementfunktion)