Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::future: risultato asincrono monouso

std::future è un handle spostabile e non copiabile a uno stato condiviso contenente un valore o un’eccezione.

Versione: C++23

Sintassi

template<class R> class std::future {
public:
    future() noexcept;
    future(future&&) noexcept;
    future(const future&) = delete;

    R get();
    bool valid() const noexcept;
    void wait() const;
    template<class Rep, class Period>
    std::future_status wait_for(const std::chrono::duration<Rep, Period>& timeout) const;

    std::shared_future<R> share() noexcept;
};

std::future<R> di <future> è l’estremità ricevente esclusiva di uno stato condiviso creato da std::promise, std::packaged_task o std::async. wait() blocca fino alla disponibilità; wait_for e wait_until riportano ready, timeout o deferred. std::future::get attende e recupera un valore spostato per future<R>, un riferimento per future<R&> o nulla per future<void>. std::future::share trasferisce lo stato a un shared_future, mentre std::future::valid verifica se l’handle possiede ancora uno stato.

L’esempio ottiene un future da std::promise<int>, avvia un thread che memorizza 42 e chiama result.get(). L’impostazione rende pronto lo stato e sincronizza il ricevente. get() restituisce 42 e poi rilascia lo stato, perciò result.valid() è falso. Dopo join() il programma stampa 42 0. La promise è catturata per riferimento ma vive fino al termine del thread.

std::future è monouso: dopo get(), share() o uno spostamento, l’origine non ha stato. Chiamare quasi ogni membro con valid() == false è comportamento indefinito; il rilevamento raccomandato con std::future_error(no_state) non è garantito. get() rilancia l’eccezione memorizzata; distruggere una std::promise senza risultato memorizza broken_promise. Per più consumatori usa std::shared_future. I membri dello stesso future non si sincronizzano fra loro: non operarvi contemporaneamente.

Esempi

#include <future>
#include <iostream>
#include <thread>

int main() {
    std::promise<int> promise;
    std::future<int> result = promise.get_future();
    std::thread producer([&promise] { promise.set_value(42); });

    const int value = result.get();
    producer.join();
    std::cout << value << ' ' << result.valid() << '\n';
}

Risultato

42 0

std::future → 42 0

Fonti