Archivo de encabezado de la biblioteca estándar <execution> (C++17)

 

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 las bibliotecas de ejecución y algoritmos.

Clases
is_execution_policy (C++17)	Comprueba si una clase representa una política de ejecución. (plantilla de clase)
Definido en el espacio de nombres std::execution
sequenced_policyparallel_policyparallel_unsequenced_policyunsequenced_policy (C++17)(C++17)(C++17)(C++20)	Tipos de políticas de ejecución. (clase)
Constantes
Definido en el espacio de nombres std::execution
seqparpar_unsequnseq (C++17)(C++17)(C++17)(C++20)	Objetos de políticas de ejecución globales. (constante)

Sinopsis

namespace std {// rasgo de tipo de política de ejecucióntemplate<class T>struct is_execution_policy;template<class T>constexprbool is_execution_policy_v = is_execution_policy<T>::value;}   namespace std::execution{// política de ejecución secuenciadaclass sequenced_policy;   // política de ejecución paralelaclass parallel_policy;   // política de ejecución paralela y no secuenciadaclass parallel_unsequenced_policy;   // unsequenced execution policyclass unsequenced_policy;   // objetos de política de ejecucióninlineconstexpr sequenced_policy seq{/* no especificado */};inlineconstexpr parallel_policy par{/* no especificado */};inlineconstexpr parallel_unsequenced_policy par_unseq{/* no especificado */};inlineconstexpr unsequenced_policy unseq{/* no especificado */};}   namespace std {// conceptos auxiliarestemplate<class T> concept /*valor-movible*/=/* véase descripción */;// solo de exposición   template<class From, class To> concept /*decae-a*/= same_as<decay_t<From>, To>;// solo de exposición   template<class T> concept /*tipo-clase*/=/*decae-a*/<T, T>&& is_class_v<T>;// solo de exposición   // objetos consultablestemplate<class T> concept /*consultable*/=/* véase descripción */;// solo de exposición   // consultasstruct forwarding_query_t {/* no especificado */};struct get_allocator_t {/* no especificado */};struct get_stop_token_t {/* no especificado */};   inlineconstexpr forwarding_query_t forwarding_query{};inlineconstexpr get_allocator_t get_allocator{};inlineconstexpr get_stop_token_t get_stop_token{};   template<class T>using stop_token_of_t = remove_cvref_t<decltype(get_stop_token(declval<T>()))>;   template<class T> concept /*consulta-de-reenvío*/= forwarding_query(T{});// solo de exposición}   namespace std::execution{// consultasstruct get_domain_t {/* no especificado */};struct get_scheduler_t {/* no especificado */};struct get_delegation_scheduler_t {/* no especificado */};struct get_forward_progress_guarantee_t {/* no especificado */};template<class CPO>struct get_completion_scheduler_t {/* no especificado */};   inlineconstexpr get_domain_t get_domain{};inlineconstexpr get_scheduler_t get_scheduler{};inlineconstexpr get_delegation_scheduler_t get_delegation_scheduler{};enumclass forward_progress_guarantee;inlineconstexpr get_forward_progress_guarantee_t get_forward_progress_guarantee{};template<class CPO>constexpr get_completion_scheduler_t<CPO> get_completion_scheduler{};   struct empty_env {};struct get_env_t {/* no especificado */};inlineconstexpr get_env_t get_env{};   template<class T>using env_of_t = decltype(get_env(declval<T>()));   // dominios de ejecuciónstruct default_domain;   // planificadoresstruct scheduler_t {};   template<class Sch> concept scheduler =/* véase descripción */;   // receptoresstruct receiver_t {};   template<class Rcvr> concept receiver =/* véase descripción */;   template<class Rcvr, class Completions> concept receiver_of =/* véase descripción */;   struct set_value_t {/* no especificado */};struct set_error_t {/* no especificado */};struct set_stopped_t {/* no especificado */};   inlineconstexpr set_value_t set_value{};inlineconstexpr set_error_t set_error{};inlineconstexpr set_stopped_t set_stopped{};   // estados de operaciónstruct operation_state_t {};   template<class O> concept operation_state =/* véase descripción */;   struct start_t;inlineconstexpr start_t start{};   // emisoresstruct sender_t {};   template<class Sndr> concept sender =/* véase descripción */;   template<class Sndr, class Env = empty_env> concept sender_in =/* véase descripción */;   template<class Sndr, class Rcvr> concept sender_to =/* véase descripción */;   template<class... Ts>struct/*lista-de-tipos*/;// solo de exposición   // signaturas de terminaciónstruct get_completion_signatures_t;inlineconstexpr get_completion_signatures_t get_completion_signatures{};   template<class Sndr, class Env = empty_env> requires sender_in<Sndr, Env>using completion_signatures_of_t =/*tipo-resultado-de-llamada*/<get_completion_signatures_t, Sndr, Env>;   template<class... Ts>using/*tupla-decaída*/= tuple<decay_t<Ts>...>;// solo de exposición   template<class... Ts>using/*variante-o-vacío*/=/* véase descripción */;// solo de exposición   template<class Sndr, class Env = empty_env, template<class...>class Tuple =/*tupla-decaída*/, template<class...>class Variant =/*variante-o-vacío*/> requires sender_in<Sndr, Env>using value_types_of_t =/* véase descripción */;   template<class Sndr, class Env = empty_env, template<class...>class Variant =/*variante-o-vacío*/> requires sender_in<Sndr, Env>using error_types_of_t =/* véase descripción */;   template<class Sndr, class Env = empty_env> requires sender_in<Sndr, Env>constexprbool sends_stopped =/* véase descripción */;   template<class Sndr, class Env>using/*tipo-valor-de-emisor-único*/=/* véase descripción */;// solo de exposición   template<class Sndr, class Env> concept /*emisor-único*/=/* véase descripción */;// solo de exposición   template<sender Sndr>using tag_of_t =/* véase descripción */;   // transformaciones de emisorestemplate<class Domain, sender Sndr, /*consultable*/... Env> requires(sizeof...(Env)<=1)constexpr sender decltype(auto) transform_sender( Domain dom, Sndr&& sndr, const Env&... env)noexcept(/* véase descripción */);   // transformaciones de entornotemplate<class Domain, sender Sndr, /*consultable*/ Env>constexpr/*consultable*/ decltype(auto) transform_env(Domain dom, Sndr&& sndr, Env&& env)noexcept;   // aplicación de algoritmo de emisortemplate<class Domain, class Tag, sender Sndr, class... Args>constexpr decltype(auto) apply_sender(Domain dom, Tag, Sndr&& sndr, Args&&... args)noexcept(/* véase descripción */);   // el algoritmo conectar emisorstruct connect_t;inlineconstexpr connect_t connect{};   template<class Sndr, class Rcvr>using connect_result_t = decltype(connect(declval<Sndr>(), declval<Rcvr>()));   // fábricas de emisoresstruct just_t {/* no especificado */};struct just_error_t {/* no especificado */};struct just_stopped_t {/* no especificado */};struct schedule_t {/* no especificado */};   inlineconstexpr just_t just{};inlineconstexpr just_error_t just_error{};inlineconstexpr just_stopped_t just_stopped{};inlineconstexpr schedule_t schedule{};inlineconstexpr/* no especificado */ read_env{};   template<scheduler Sndr>using schedule_result_t = decltype(schedule(declval<Sndr>()));   // adaptadores de emisorestemplate</*tipo-clase*/ D>struct sender_adaptor_closure {};   struct starts_on_t {/* no especificado */};struct continues_on_t {/* no especificado */};struct on_t {/* no especificado */};struct schedule_from_t {/* no especificado */};struct then_t {/* no especificado */};struct upon_error_t {/* no especificado */};struct upon_stopped_t {/* no especificado */};struct let_value_t {/* no especificado */};struct let_error_t {/* no especificado */};struct let_stopped_t {/* no especificado */};struct bulk_t {/* no especificado */};struct split_t {/* no especificado */};struct when_all_t {/* no especificado */};struct when_all_with_variant_t {/* no especificado */};struct into_variant_t {/* no especificado */};struct stopped_as_optional_t {/* no especificado */};struct stopped_as_error_t {/* no especificado */};   inlineconstexpr starts_on_t starts_on{};inlineconstexpr continues_on_t continues_on{};inlineconstexpr on_t on{};inlineconstexpr schedule_from_t schedule_from{};inlineconstexpr then_t then{};inlineconstexpr upon_error_t upon_error{};inlineconstexpr upon_stopped_t upon_stopped{};inlineconstexpr let_value_t let_value{};inlineconstexpr let_error_t let_error{};inlineconstexpr let_stopped_t let_stopped{};inlineconstexpr bulk_t bulk{};inlineconstexpr split_t split{};inlineconstexpr when_all_t when_all{};inlineconstexpr when_all_with_variant_t when_all_with_variant{};inlineconstexpr into_variant_t into_variant{};inlineconstexpr stopped_as_optional_t stopped_as_optional{};inlineconstexpr stopped_as_error_t stopped_as_error{};   // servicios de emisores y receptores   template<class Fn> concept /*signatura-de-terminación*/=/* véase descripción */;// solo de exposición   template</*signatura-de-terminación*/... Fns>struct completion_signatures {};   template<class Sigs> concept /*signaturas-de-terminación-válidas*/=/* véase descripción */;// solo de exposición   template</*signaturas-de-terminación-válidas*/ InputSignatures, /*signaturas-de-terminación-válidas*/ AdditionalSignatures = completion_signatures<>, template<class...>class SetValue =/* véase descripción */, template<class>class SetError =/* véase descripción */, /*signaturas-de-terminación-válidas*/ SetStopped = completion_signatures<set_stopped_t()>>using transform_completion_signatures = completion_signatures</* véase descripción */>;   template<sender Sndr, class Env = empty_env, /*signaturas-de-terminación-válidas*/ AdditionalSignatures = completion_signatures<>, template<class...>class SetValue =/* véase descripción */, template<class>class SetError =/* véase descripción */, /*signaturas-de-terminación-válidas*/ SetStopped = completion_signatures<set_stopped_t()>> requires sender_in<Sndr, Env>using transform_completion_signatures_of = transform_completion_signatures<completion_signatures_of_t<Sndr, Env>, AdditionalSignatures, SetValue, SetError, SetStopped>;   // bucle de ejecuciónclass run_loop;}   namespace std::this_thread{// consumidoresstruct sync_wait_t {/* no especificado */};struct sync_wait_with_variant_t {/* no especificado */};   inlineconstexpr sync_wait_t sync_wait{};inlineconstexpr sync_wait_with_variant_t sync_wait_with_variant{};}   namespace std::execution{struct as_awaitable_t {/* no especificado */};inlineconstexpr as_awaitable_t as_awaitable{};   template</*tipo-clase*/ Promise>struct with_awaitable_senders;}

Conceptos auxiliares

namespace std {template<class T> concept /*valor-movible*/=// solo de exposición move_constructible<decay_t<T>>&& constructible_from<decay_t<T>, T>&&(!is_array_v<remove_reference_t<T>>);}   namespace std {template<class T> concept /*consultable*/= destructible<T>;// solo de exposición}   namespace std::execution{template<class Sndr, class Env> concept /*emisor-único*/= sender_in<Sndr, Env>&& requires {typename/*tipo-valor-de-emisor-único*/<Sndr, Env>;};}

Clases auxiliares

namespace std::execution{struct/*variante-vació*/{// solo de exposición/*variante-vació*/()= delete;};}

enumstd::forward_progress_guarantee

namespace std::execution{enumclass forward_progress_guarantee { concurrent, parallel, weakly_parallel };}

Concepto scheduler

namespace std::execution{template<class Sch> concept scheduler = derived_from<typename remove_cvref_t<Sch>::scheduler_concept, scheduler_t>&&/*consultable*/<Sch>&& requires(Sch&& sch){{ schedule(std::forward<Sch>(sch))}-> sender;{auto(get_completion_scheduler<set_value_t>( get_env(schedule(std::forward<Sch>(sch)))))}-> same_as<remove_cvref_t<Sch>>;}&& equality_comparable<remove_cvref_t<Sch>>&& copy_constructible<remove_cvref_t<Sch>>;}

Concepto receiver

namespace std::execution{template<class Rcvr> concept receiver = derived_from<typename remove_cvref_t<Rcvr>::receiver_concept, receiver_t>&& requires(const remove_cvref_t<Rcvr>& rcvr){{ get_env(rcvr)}->/*consultable*/;}&& move_constructible<remove_cvref_t<Rcvr>>&&// r-valores son movibles, y constructible_from<remove_cvref_t<Rcvr>, Rcvr>;// l-valores son copiables   template<class Signature, class Rcvr> concept /*terminación-válida-para*/= requires(Signature* sig){[]<class Tag, class... Args>(Tag(*)(Args...)) requires /*invocable*/<Tag, remove_cvref_t<Rcvr>, Args...>{}(sig);};   template<class Rcvr, class Completions> concept /*tiene-terminaciones*/= requires(Completions* completions){[]</*terminación-válida-para*/<Rcvr>... Sigs>(completion_signatures<Sigs...>*){}(completions);};   template<class Rcvr, class Completions> concept receiver_of = receiver<Rcvr>&&/*tiene-terminaciones*/<Rcvr, Completions>;}

Concepto operation_state

namespace std::execution{template<class O> concept operation_state = derived_from<typename O::operation_state_concept, operation_state_t>&& is_object_v<O>&& requires(O& o){{ start(o)}noexcept;};}