Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

std::future: resultado asíncrono de un solo uso

std::future es un manejador movible y no copiable hacia un estado compartido que contiene un valor o una excepción.

Versión: C++23

Sintaxis

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 el extremo receptor exclusivo de un estado compartido creado por std::promise, std::packaged_task o std::async. wait() bloquea hasta que esté listo; wait_for y wait_until indican ready, timeout o deferred. std::future::get espera y obtiene un valor movido para future<R>, una referencia para future<R&> o nada para future<void>. std::future::share transfiere el estado a un shared_future, y std::future::valid comprueba si el manejador aún tiene estado.

El ejemplo obtiene un future de std::promise<int>, inicia un hilo que almacena 42 y llama a result.get(). Establecer el valor prepara el estado y sincroniza al receptor. get() devuelve 42 y libera el estado, por lo que result.valid() es falso. Tras join(), el programa imprime 42 0. La promise se captura por referencia, pero vive hasta que termina el hilo.

std::future es de un solo uso: después de get(), share() o un movimiento, el objeto origen no tiene estado. Llamar a casi cualquier miembro con valid() == false es comportamiento indefinido; la detección recomendada mediante std::future_error(no_state) no está garantizada. get() relanza una excepción guardada y destruir una std::promise sin resultado guarda broken_promise. Usa std::shared_future para varios consumidores. Los miembros del mismo future no se sincronizan entre sí, así que no operes concurrentemente sobre un objeto.

Ejemplos

#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

Fuentes