Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

std::future: resultado assíncrono de utilização única

std::future é um handle movível e não copiável para um estado partilhado que contém um valor ou uma exceção.

Versão: C++23

Sintaxe

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> representa a extremidade recetora exclusiva de um estado partilhado criado por std::promise, std::packaged_task ou std::async. wait() bloqueia até ficar pronto; wait_for e wait_until indicam ready, timeout ou deferred. std::future::get espera e retira um valor movido para future<R>, uma referência para future<R&> ou nada para future<void>. std::future::share transfere o estado para um shared_future, e std::future::valid verifica se o handle ainda possui um estado.

O exemplo obtém um future de std::promise<int>, inicia uma thread que guarda 42 e chama result.get(). Definir o valor prepara o estado e sincroniza o recetor. get() devolve 42 e liberta o estado, logo result.valid() fica falso. Após join(), o programa imprime 42 0. A promise é capturada por referência, mas vive até a thread terminar.

std::future é de utilização única: depois de get(), share() ou movimento, a origem fica sem estado. Chamar quase qualquer membro com valid() == false tem comportamento indefinido; a deteção recomendada por std::future_error(no_state) não é garantida. get() relança uma exceção guardada e destruir std::promise sem resultado guarda broken_promise. Para vários consumidores usa std::shared_future. Os membros do mesmo future não se sincronizam entre si; não operes concorrentemente num objeto.

Exemplos

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

Resultado

42 0

std::future → 42 0

Fontes