Namensräume
Varianten
Aktionen

std::future<T>::get

Von cppreference.com
< cpp‎ | thread‎ | future
 
 
Bibliothek für nebenläufige Programmierung
Threads
(C++11)
(C++20)
this_thread Namespace
(C++11)
(C++11)
(C++11)
Kooperatives Beenden
Gegenseitiger Ausschluss
(C++11)
Allgemeines Sperrungsmanagement
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Bedingungsvariablen
(C++11)
Semaphoren
Latches und Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
(C++11)
Sichere Wiederherstellung
(C++26)
Hazard Pointer
Atomare Typen
(C++11)
(C++20)
Initialisierung von atomaren Typen
(C++11)(veraltet in C++20)
(C++11)(veraltet in C++20)
Speicherordnung
(C++11)(deprecated in C++26)
Freie Funktionen für atomare Operationen
Freie Funktionen für atomare Flags
 
 
Hauptvorlage
T get();
(1) (seit C++11)
std::future<T&> Spezialisierungen
T& get();
(2) (seit C++11)
std::future<void> Spezialisierung
void get();
(3) (seit C++11)

Die Memberfunktion get wartet (durch Aufruf von wait()), bis der gemeinsame Zustand bereit ist, und ruft dann den im gemeinsamen Zustand gespeicherten Wert ab (falls vorhanden). Unmittelbar nach dem Aufruf dieser Funktion ist valid() false.

Wenn valid() vor dem Aufruf dieser Funktion false ist, ist das Verhalten undefiniert.

Inhalt

[bearbeiten] Rückgabewert

1) Der im gemeinsamen Zustand gespeicherte Wert v, als std::move(v).
2) Die als Wert im gemeinsamen Zustand gespeicherte Referenz.
3) (keine)

[bearbeiten] Ausnahmen

Wenn eine Ausnahme im gemeinsamen Zustand gespeichert wurde, auf den sich das Future bezieht (z. B. durch Aufruf von std::promise::set_exception()), dann wird diese Ausnahme ausgelöst.

[bearbeiten] Hinweise

Der C++-Standard empfiehlt, dass Implementierungen den Fall erkennen, wenn valid() vor dem Aufruf false ist und eine std::future_error mit der Fehlerbedingung std::future_errc::no_state auslösen.

[bearbeiten] Beispiel

#include <chrono>
#include <future>
#include <iostream>
#include <string>
#include <thread>
 
std::string time()
{
    static auto start = std::chrono::steady_clock::now();
    std::chrono::duration<double> d = std::chrono::steady_clock::now() - start;
    return "[" + std::to_string(d.count()) + "s]";
}
 
int main()
{
    using namespace std::chrono_literals;
 
    {
        std::cout << time() << " launching thread\n";
        std::future<int> f = std::async(std::launch::async, []
        {
            std::this_thread::sleep_for(1s);
            return 7;
        });
        std::cout << time() << " waiting for the future, f.valid() = "
                  << f.valid() << '\n';
        int n = f.get();
        std::cout << time() << " f.get() returned " << n << ", f.valid() = "
                  << f.valid() << '\n';
    }
 
    {
        std::cout << time() << " launching thread\n";
        std::future<int> f = std::async(std::launch::async, []
        {
            std::this_thread::sleep_for(1s);
            return true ? throw std::runtime_error("7") : 7;
        });
        std::cout << time() << " waiting for the future, f.valid() = "
                  << f.valid() << '\n';
 
        try
        {
            int n = f.get();
            std::cout << time() << " f.get() returned " << n
                      << ", f.valid() = " << f.valid() << '\n';
        }
        catch (const std::exception& e)
        {
            std::cout << time() << " caught exception " << e.what()
                      << ", f.valid() = " << f.valid() << '\n';
        }
    }
}

Mögliche Ausgabe

[0.000004s] launching thread
[0.000461s] waiting for the future, f.valid() = 1
[1.001156s] f.get() returned with 7, f.valid() = 0
[1.001192s] launching thread
[1.001275s] waiting for the future, f.valid() = 1
[2.002356s] caught exception 7, f.valid() = 0

[bearbeiten] Fehlerberichte

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

DR angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
LWG 2096 C++11 Überladung (1) benötigt, um zu prüfen, ob T MoveAssignable ist nicht erforderlich.

[bearbeiten] Siehe auch

prüft, ob das Future einen gemeinsamen Zustand hat
(public member function) [bearbeiten]