CKTIS / C++
std::future_status — resultado de uma espera com limite de tempo
std::future_status é uma enumeração com âmbito definido de <future>, devolvida por wait_for() e wait_until(). Distingue um resultado pronto, o fim do tempo limite e uma execução diferida. O estado, por si só, não obtém o valor nem indica se o cálculo terminou sem exceção.
Versão: C++23; repository compiler flag, production runtime not attested
Sintaxe
#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 é um enum class de <future>. Os membros wait_for() e wait_until() de std::future<T> e std::shared_future<T> devolvem este tipo. O primeiro recebe uma duração; o segundo, um ponto no tempo. Verificam se o estado partilhado está pronto, sem obter o resultado.
std::future_status::ready significa que o estado partilhado contém um valor ou uma exceção pronta a ser obtida. Não garante que o cálculo tenha sido bem-sucedido: get() pode voltar a lançar a exceção armazenada. std::future_status::timeout significa que a espera terminou porque o tempo limite expirou; não cancela a tarefa nem prova que esta ainda esteja a decorrer quando examina o estado.
std::future_status::deferred significa que o estado contém uma função diferida, por exemplo, criada por std::async(std::launch::deferred, ...). Uma espera com limite de tempo não a inicia e devolve este estado sem aguardar pelo fim do limite. A primeira espera sem limite, através de wait() ou get(), executa-a na thread que fez a chamada. Um ciclo que apenas consulta wait_for() não iniciará essa tarefa.
Chame os membros de espera apenas num objeto com um estado partilhado: valid() não significa ready. Para std::future<T>, chamar get() consome o resultado e deixa valid() == false; esperar depois nesse objeto tem comportamento indefinido. O exemplo verifica deterministicamente os três estados com wait_for(0ms), uma promise e uma tarefa explicitamente diferida, sem adormecer a thread. As páginas citadas apresentam um projeto de trabalho em evolução, não um texto C++23 congelado.
Exemplos
#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';
}
Resultado
timeout: true ready: true deferred: true values: 42 7
O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.