Ver el código de «cpp/header/future»

No tienes permiso para modificar esta página, por el siguiente motivo:
La acción que has solicitado está restringida a los usuarios de uno de estos 2 grupos: Usuarios, Administradores.
Puedes ver y copiar el código fuente de esta página.
{{cpp/header/title|future}}
{{cpp/header/navbar}}
Este archivo de encabezado es parte de la biblioteca de [[cpp/thread|soporte de hilos]].
{{dsc begin}}
{{dsc h1|Clases}}
{{dsc inc | cpp/thread/dsc promise}}
{{dsc inc | cpp/thread/dsc packaged_task}}
{{dsc inc | cpp/thread/dsc future}}
{{dsc inc | cpp/thread/dsc shared_future}}
{{dsc inc | cpp/thread/dsc launch}}
{{dsc inc | cpp/thread/dsc future_status}}
{{dsc inc | cpp/thread/dsc future_error}}
{{dsc inc | cpp/thread/dsc future_errc}}
{{dsc inc | cpp/thread/promise/dsc uses_allocator}}
{{dsc inc | cpp/thread/packaged_task/dsc uses_allocator}}
{{dsc h1|Funciones}}
{{dsc inc | cpp/thread/dsc async}}
{{dsc inc | cpp/thread/dsc future_category}}
{{dsc inc | cpp/thread/promise/dsc swap2}}
{{dsc inc | cpp/thread/packaged_task/dsc swap2}}
{{dsc end}}

===Sinopsis===
{{source|1=
namespace std {
  enum class 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 */
  };

  enum class launch : /* sin especificar */ {
    async = /* sin especificar */,
    deferred = /* sin especificar */,
    /* definido por la implementación */
  };

  enum class 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 definir
  template<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 {{lc|std::future_error}}====
{{source|1=
namespace std {
  class future_error : public logic_error {
  public:
    explicit future_error(future_errc e);

    const error_code& code() const noexcept;
    const char*       what() const noexcept;

  private:
    error_code ec_;             // solo exposición
  };
}
}}

====Plantilla de clase {{lc|std::promise}}====
{{source|1=
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 resultado
    void set_value(/* véase descripción */);
    void set_exception(exception_ptr p);

    // establecer el resultado con notificación diferida
    void 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 {{lc|std::future}}====
{{source|1=
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 estado
    bool valid() const noexcept;

    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 {{lc|std::shared_future}}====
{{source|1=
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 estado
    bool valid() const noexcept;

    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 {{lc|std::packaged_task}}====
{{source|1=
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() const noexcept;

    // recuperación del resultado
    future<R> get_future();

    // ejecución
    void 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;
}
}}

{{langlinks|en|ja|zh}}
Plantillas usadas en esta página:
cppreference.com

Buscar

Espacios de nombres

Variantes

Vistas

Acciones

Ver el código de «cpp/header/future»
