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