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

CKTIS / C++

std::future_status — résultat d’une attente avec délai

std::future_status est une énumération à portée définie de <future>, renvoyée par wait_for() et wait_until(). Elle distingue un résultat prêt, l’expiration du délai et une exécution différée. Le statut lui-même ne récupère pas la valeur et n’indique pas si le calcul s’est terminé sans exception.

Version : C++23; repository compiler flag, production runtime not attested

Syntaxe

#include <future>
// Declared in namespace std:
enum class future_status { ready, timeout, deferred };
// f.wait_for(duration) and f.wait_until(time_point) return std::future_status.

std::future_status est un enum class de <future>. Les membres wait_for() et wait_until() de std::future<T> et std::shared_future<T> renvoient ce type. Le premier prend une durée, le second un instant. Ils vérifient si l’état partagé est prêt, sans récupérer le résultat.

std::future_status::ready signifie que l’état partagé contient une valeur ou une exception prête à être récupérée. Cela ne garantit pas la réussite du calcul : get() peut relancer l’exception stockée. std::future_status::timeout signifie que l’attente s’est terminée parce que le délai a expiré ; cela n’annule pas la tâche et ne prouve pas qu’elle est encore en cours au moment où vous examinez le statut.

std::future_status::deferred signifie que l’état contient une fonction différée, par exemple créée par std::async(std::launch::deferred, ...). Une attente avec délai ne la démarre pas et renvoie ce statut sans attendre l’expiration du délai. La première attente sans délai, via wait() ou get(), l’exécute dans le thread appelant. Une boucle qui se limite à interroger wait_for() ne démarrera pas une telle tâche.

N’appelez les membres d’attente que sur un objet doté d’un état partagé : valid() ne signifie pas ready. Pour std::future<T>, appeler get() consomme le résultat et laisse valid() == false ; attendre ensuite sur cet objet entraîne un comportement indéfini. L’exemple vérifie de façon déterministe les trois statuts avec wait_for(0ms), une promesse et une tâche explicitement différée, sans pause. Les pages citées présentent un projet de travail évolutif, et non un texte C++23 figé.

Exemples

#include <chrono>
#include <future>
#include <iostream>

int main() {
    using namespace std::chrono_literals;
    std::cout << std::boolalpha;

    std::promise<int> producer;
    auto result = producer.get_future();
    std::cout << "timeout: "
              << (result.wait_for(0ms) == std::future_status::timeout) << '\n';

    producer.set_value(42);
    std::cout << "ready: "
              << (result.wait_for(0ms) == std::future_status::ready) << '\n';

    auto lazy = std::async(std::launch::deferred, [] { return 7; });
    std::cout << "deferred: "
              << (lazy.wait_for(0ms) == std::future_status::deferred) << '\n';

    std::cout << "values: " << result.get() << ' ' << lazy.get() << '\n';
}

Résultat

timeout: true
ready: true
deferred: true
values: 42 7

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources