`std::future` în C++

Un rezultat care va fi disponibil în viitor (de la std::async sau std::promise); get() îl așteaptă și îl returnează.

Sintaxă

#include <future>
T get();
void wait() const;
std::future_status wait_for(const std::chrono::duration<Rep, Period>& durata) const;
bool valid() const noexcept;

Ce face `std::future`

std::future<T> este „capătul de citire” al unui rezultat calculat în altă parte. Îl primești de la std::async, de la std::promise::get_future() sau de la std::packaged_task.

get() așteaptă până când rezultatul este gata și îl returnează (sau aruncă excepția produsă). Se poate apela o singură dată; după aceea valid() devine false. wait() doar așteaptă, iar wait_for(durata) așteaptă cel mult durata dată și returnează std::future_status::ready sau timeout.

Ce returnează

get() returnează valoarea de tip T.

Exemple

Exemplul 1: valid() înainte și după get()

#include <future>
#include <print>

int main() {
    std::future<int> f = std::async(std::launch::async, [] { return 6 * 7; });
    std::println("valid: {}", f.valid());
    std::println("rezultat: {}", f.get());
    std::println("valid după get: {}", f.valid());
}

Rezultat

valid: true
rezultat: 42
valid după get: false

Exemplul 2: Așteptare cu limită de timp

Calculul durează 200 ms, iar prima așteptare doar 50 ms, deci expiră. Rezultatul este același la fiecare rulare, pentru că diferența de timp este mare.

#include <chrono>
#include <future>
#include <print>
#include <thread>

int main() {
    using namespace std::chrono_literals;
    auto f = std::async(std::launch::async, [] {
        std::this_thread::sleep_for(200ms);
        return 100;
    });

    if (f.wait_for(50ms) == std::future_status::timeout) {
        std::println("Încă se calculează...");
    }
    f.wait();
    std::println("Gata: {}", f.get());
}