Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

std::future : résultat asynchrone à usage unique

std::future est un handle déplaçable non copiable vers un état partagé contenant une valeur ou une exception.

Version : C++23

Syntaxe

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> de <future> représente l’extrémité réceptrice exclusive d’un état partagé créé par std::promise, std::packaged_task ou std::async. wait() bloque jusqu’à disponibilité ; wait_for et wait_until renvoient ready, timeout ou deferred. std::future::get attend puis retire une valeur déplacée pour future<R>, une référence pour future<R&> ou rien pour future<void>. std::future::share transfère l’état vers un shared_future, et std::future::valid vérifie si le handle possède encore un état.

L’exemple obtient un future depuis std::promise<int>, lance un thread qui fournit 42, puis appelle result.get(). La fourniture rend l’état prêt et synchronise le récepteur. get() renvoie 42 puis libère l’état ; result.valid() devient donc faux. Après join(), le programme affiche 42 0. La promise est capturée par référence mais reste vivante jusqu’à la fin du thread.

std::future est à usage unique : après get(), share() ou un déplacement, la source n’a plus d’état. Appeler la plupart des membres quand valid() == false est indéfini ; la détection recommandée par std::future_error(no_state) n’est pas garantie. get() relance l’exception stockée, tandis que détruire une std::promise sans résultat stocke broken_promise. Pour plusieurs lecteurs, utilisez std::shared_future. Les membres du même future ne se synchronisent pas entre eux : ne les appelez pas concurremment sur un objet.

Exemples

#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';
}

Résultat

42 0

std::future → 42 0

Sources