Archivo de encabezado de la biblioteca estándar <future>

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos(C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación(C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos(C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos(C++17)

Biblioteca de apoyo de concurrencia(C++11)

Biblioteca de apoyo de ejecución(C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Archivos de encabezado de la biblioteca estándar

Apoyo del lenguaje <cfloat> <climits> <compare>(C++20) <coroutine>(C++20) <csetjmp> <csignal> <cstdarg> <cstddef> <cstdint>(C++11) <cstdlib> <exception> <initializer_list>(C++11)    <limits> <new> <source_location>(C++20) <stdfloat>(C++23) <typeinfo> <version>(C++20) Conceptos <concepts>(C++20) Diagnósticos <cassert> <cerrno> <debugging>(C++26) <stacktrace>(C++23) <stdexcept> <system_error>(C++11) Gestión de memoria <memory> <memory_resource>(C++17) <scoped_allocator>(C++11) Metaprogramación <type_traits>(C++11) <ratio>(C++11)

Servicios generales <any>(C++17) <bitset> <bit>(C++20) <charconv>(C++17) <expected>(C++23) <format>(C++20) <functional> <optional>(C++17) <tuple>(C++11) <typeindex>(C++11) <utility> <variant>(C++17) Contenedores <array>(C++11) <deque> <flat_map>(C++23) <flat_set>(C++23) <forward_list>(C++11) <inplace_vector>(C++26)    <list> <map> <mdspan>(C++23) <queue> <set> <span>(C++20) <stack> <unordered_map>(C++11) <unordered_set>(C++11) <vector> Iteradores <iterator> Rangos <generator>(C++23) <ranges>(C++20)

Algoritmos <algorithm> <numeric> Cadenas <cctype> <cstring> <cuchar>(C++11) <cwchar> <cwctype> <string_view>(C++17) <string> Procesamiento de texto <clocale> <codecvt>(C++11/17/26*) <locale> <regex>(C++11) <text_encoding>(C++26)    Numéricos <cfenv>(C++11) <cmath> <complex> <linalg>(C++26) <numbers>(C++20) <random>(C++11) <simd>(C++26) <valarray> Tiempo <chrono>(C++11) <ctime> Compatibilidad con C <ccomplex>(C++11/17/20*) <ciso646>(hasta C++20) <cstdalign>(C++11/17/20*) <cstdbool>(C++11/17/20*) <ctgmath>(C++11/17/20*)

Entrada/Salida <cinttypes>(C++11) <cstdio> <filesystem>(C++17) <fstream> <iomanip> <iosfwd> <iostream> <ios> <istream> <ostream> <print>(C++23) <spanstream>(C++23) <sstream> <streambuf> <strstream>(C++98/26*) <syncstream>(C++20) Apoyo para concurrencia <atomic>(C++11) <barrier>(C++20) <condition_variable>(C++11) <future>(C++11) <hazard_pointer>(C++26) <latch>(C++20) <mutex>(C++11) <rcu>(C++26) <semaphore>(C++20) <shared_mutex>(C++14) <stdatomic.h>(C++23) <stop_token>(C++20) <thread>(C++11) Apoyo de ejecución <execution>(C++17)

 

Este archivo de encabezado es parte de la biblioteca de soporte de hilos.

Clases
promise (C++11)	Almacena un valor para recuperación asíncrona. (plantilla de clase)
packaged_task (C++11)	Empaqueta una función para almacenar su valor de retorno para la recuperación asíncrona. (plantilla de clase)
future (C++11)	Espera a un valor que se establece asíncronamente. (plantilla de clase)
shared_future (C++11)	Espera a un valor (posiblemente referenciado por otros futuros) que se ha establecido asíncronamente. (plantilla de clase)
launch (C++11)	Especifica la política de lanzamiento de std::async. (enum)
future_status (C++11)	Especifica los resultados de esperas cronometradas realizadas en std::future y std::shared_future. (enum)
future_error (C++11)	Informa de un error relacionado con futuros o promesas. (clase)
future_errc (C++11)	Identifica los códigos de error del futuro. (enum)
std::uses_allocator<std::promise> (C++11)	Especializa el rasgo de tipo std::uses_allocator (especialización de plantilla de clase)
std::uses_allocator<std::packaged_task> (C++11)	Especializa al rasgo de tipo std::uses_allocator (especialización de plantilla de clase)
Funciones
async (C++11)	Ejecuta una función asíncronamente (posiblemente en un nuevo hilo) y devuelve un std::future que contendrá el resultado. (plantilla de función)
future_category (C++11)	Identifica la categoría de error del futuro. (función)
std::swap(std::promise) (C++11)	Especializa el algoritmo std::swap. (plantilla de función)
std::swap(std::packaged_task) (C++11)	Especializa al algoritmo std::swap. (plantilla de función)

Sinopsis

namespace std {enumclass future_errc { broken_promise =/* definido por la implementación */, future_already_retrieved =/* definido por la implementación */, promise_already_satisfied =/* definido por la implementación */, no_state =/* definido por la implementación */};   enumclass launch :/* sin especificar */{ async =/* sin especificar */, deferred =/* sin especificar */, /* definido por la implementación */};   enumclass future_status { ready, timeout, deferred };   template<>struct is_error_code_enum<future_errc>:public true_type {}; error_code make_error_code(future_errc e)noexcept; error_condition make_error_condition(future_errc e)noexcept;   const error_category& future_category()noexcept;   class future_error;   template<class R>class promise;template<class R>class promise<R&>;template<>class promise<void>;   template<class R>void swap(promise<R>& x, promise<R>& y)noexcept;   template<class R, class Alloc>struct uses_allocator<promise<R>, Alloc>;   template<class R>class future;template<class R>class future<R&>;template<>class future<void>;   template<class R>class shared_future;template<class R>class shared_future<R&>;template<>class shared_future<void>;   template<class>class packaged_task;// sin definirtemplate<class R, class... ArgTypes>class packaged_task<R(ArgTypes...)>;   template<class R, class... ArgTypes>void swap(packaged_task<R(ArgTypes...)>&, packaged_task<R(ArgTypes...)>&)noexcept;   template<class F, class... Args>[[nodiscard]] future<invoke_result_t<decay_t<F>, decay_t<Args>...>> async(F&& f, Args&&... args);template<class F, class... Args>[[nodiscard]] future<invoke_result_t<decay_t<F>, decay_t<Args>...>> async(launch policy, F&& f, Args&&... args);}

Clase std::future_error

namespace std {class future_error :public logic_error {public:explicit future_error(future_errc e);   const error_code& code()constnoexcept;constchar* what()constnoexcept;   private: error_code ec_;// solo exposición};}

Plantilla de clase std::promise

namespace std {template<class R>class promise {public: promise();template<class Allocator> promise(allocator_arg_t, const Allocator& a); promise(promise&& rhs)noexcept; promise(const promise&)= delete; ~promise();   // asignación promise& operator=(promise&& rhs)noexcept; promise& operator=(const promise&)= delete;void swap(promise& other)noexcept;   // recuperar el resultado future<R> get_future();   // establecer el resultadovoid set_value(/* véase descripción */);void set_exception(exception_ptr p);   // establecer el resultado con notificación diferidavoid set_value_at_thread_exit(/* véase descripción */);void set_exception_at_thread_exit(exception_ptr p);};   template<class R>void swap(promise<R>& x, promise<R>& y)noexcept;   template<class R, class Alloc>struct uses_allocator<promise<R>, Alloc>;}

Plantilla de clase std::future

namespace std {template<class R>class future {public: future()noexcept; future(future&&)noexcept; future(const future&)= delete; ~future(); future& operator=(const future&)= delete; future& operator=(future&&)noexcept; shared_future<R> share()noexcept;   // recuperar el resultado/* véase descripción */ get();   // funciones para comprobar estadobool valid()constnoexcept;   void wait()const;template<class Rep, class Period> future_status wait_for(const chrono::duration<Rep, Period>& rel_time)const;template<class Clock, class Duration> future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time)const;};}

Plantilla de clase std::shared_future

namespace std {template<class R>class shared_future {public: shared_future()noexcept; shared_future(const shared_future& rhs)noexcept; shared_future(future<R>&&)noexcept; shared_future(shared_future&& rhs)noexcept; ~shared_future(); shared_future& operator=(const shared_future& rhs)noexcept; shared_future& operator=(shared_future&& rhs)noexcept;   // recuperar el valor/* véase descripción */ get()const;   // funciones para comprobar estadobool valid()constnoexcept;   void wait()const;template<class Rep, class Period> future_status wait_for(const chrono::duration<Rep, Period>& rel_time)const;template<class Clock, class Duration> future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time)const;};}

Plantilla de clase std::packaged_task

namespace std {template<class>class packaged_task;// sin definir   template<class R, class... ArgTypes>class packaged_task<R(ArgTypes...)>{public:// construcción y destrucción packaged_task()noexcept;template<class F>explicit packaged_task(F&& f); ~packaged_task();   // no se permite copia packaged_task(const packaged_task&)= delete; packaged_task& operator=(const packaged_task&)= delete;   // soporte de semántica de movimiento packaged_task(packaged_task&& rhs)noexcept; packaged_task& operator=(packaged_task&& rhs)noexcept;void swap(packaged_task& other)noexcept;   bool valid()constnoexcept;   // recuperación del resultado future<R> get_future();   // ejecuciónvoid operator()(ArgTypes... );void make_ready_at_thread_exit(ArgTypes...);   void reset();};   template<class R, class... ArgTypes>void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgTypes...)>& y)noexcept;}