Compartir a través de

optional (clase)

La plantilla de clase optional<T> describe un objeto que puede contener o no un valor de tipo T, conocido como el valor contenido.

Cuando una instancia de optional<T> contiene un valor, el valor contenido se asigna dentro del almacenamiento del objeto optional, en una región alineada correctamente para el tipo T. Cuando se convierte un optional<T> en bool, el resultado es true si el objeto contiene un valor; de lo contrario, es false.

El tipo T de objeto contenido no debe ser in_place_t ni nullopt_t. T debe ser destructible, es decir, su destructor debe reclamar todos los recursos propiedad y no puede producir ninguna excepción.

La clase optional es nueva en C++17.

Sintaxis

template <class T>
class optional
{
    using value_type = T;
};

template<class T> optional(T) -> optional<T>;

Miembros

Constructores

Nombre Descripción
Constructores y destructor
opcional Construye un objeto de tipo optional.
~optional Destruye un objeto de tipo optional.
Cesión
operator= Reemplaza la clase optional por una copia de otra clase optional.
emplace Inicializa el valor contenido con argumentos especificados.
Swap
swap Intercambia el valor contenido o el estado vacío con otra clase optional.
Observadores
has_value Devuelve si un objeto optional contiene un valor.
value Devuelve el valor contenido.
value_or Devuelve el valor contenido o una alternativa si no hay ningún valor presente.
operator-> Hace referencia al valor contenido de un objeto optional.
operator* Hace referencia al valor contenido de un objeto optional.
operator bool Devuelve si un objeto optional contiene un valor.
Modificadores
reset Restablece la clase optional mediante la destrucción de cualquier valor contenido.

has_value

constexpr bool has_value() const noexcept;

optional (constructor)

Construye un objeto de tipo optional.

constexpr optional() noexcept;
constexpr optional(nullopt_t nullopt) noexcept;
constexpr optional(const optional& rhs);
constexpr optional(optional&& rhs) noexcept;

template <class... Args>
constexpr explicit optional(in_place_t, Args&&... args);

template <class U, class... Args>
constexpr explicit optional(in_place_t, initializer_list<U> i_list, Args&&... args);

template <class U = T>
explicit constexpr optional(U&& rhs);

template <class U>
explicit optional(const optional<U>& rhs);

template <class U>
explicit optional(optional<U>&& rhs);

Parámetros

rhs
El optional a partir del cual se va construir la copia o el movimiento del valor contenido.

i_list
Lista de inicializadores a partir de la que se va a construir el valor contenido.

args
Lista de argumentos a partir de la que se va a construir el valor contenido.

Comentarios

constexpr optional() noexcept;constexpr optional(nullopt_t nullopt) noexcept; Estos constructores construyen un optional que no contiene un valor.

constexpr optional(const optional& rhs); El constructor de copia inicializa el valor contenido del valor contenido del argumento. Se define como eliminado a menos is_copy_constructible_v<T> que sea true y es trivial si is_trivially_copy_constructible_v<T> es true.

constexpr optional(optional&& rhs) noexcept; El constructor de movimiento inicializa el valor contenido moviendo desde el valor contenido del argumento. No participa en la resolución de sobrecargas a menos que is_move_constructible_v<T> sea true y es trivial si is_trivially_move_constructible_v<T> es true.

template <class... Args> constexpr explicit optional(in_place_t, Args&&... args); Inicializa directamente el valor contenido como si usara los argumentos std::forward<Args>(args). Este constructor es constexpr si el constructor T utilizado es constexpr. No participa en la resolución de sobrecarga a menos que is_constructible_v<T, Args...> sea true.

template <class U, class... Args> constexpr explicit optional(in_place_t, initializer_list<U> i_list, Args&&... args); Inicializa directamente el valor contenido como si usara los argumentos i_list, std::forward<Args>(args). Este constructor es constexpr si el constructor T utilizado es constexpr. No participa en la resolución de sobrecarga a menos que is_constructible_v<T, initializer_list<U>&, Args&&...> sea true.

template <class U = T> explicit constexpr optional(U&& rhs); Inicializa directamente el valor contenido como si usara std::forward<U>(v). Este constructor es constexpr si el constructor T utilizado es constexpr. No participa en la resolución de sobrecargas a menos que is_constructible_v<T, U&&> sea true y is_same_v<remove_cvref_t<U>, in_place_t> y is_same_v<remove_cvref_t<U>, optional> sean false.

template <class U> explicit optional(const optional<U>& rhs); Si rhs contiene un valor, inicializa directamente el valor contenido del valor contenido del argumento. No participa en la resolución de sobrecargas a menos que is_constructible_v<T, const U&> sea true, y is_constructible_v<T, optional<U>&>, is_constructible_v<T, optional<U>&&>, is_constructible_v<T, const optional<U>&>is_constructible_v<T, const optional<U>&&>is_convertible_v<optional<U>&, T>is_convertible_v<optional<U>&&, T>is_convertible_v<const optional<U>&, T> y is_convertible_v<const optional<U>&&, T> sean todos false.

template <class U> explicit optional(optional<U>&& rhs); Si rhs contiene un valor, inicializa directamente el valor contenido como si usara std::move(*rhs). No participa en la resolución de sobrecargas a menos que is_constructible_v<T, U&&> sea true, y is_constructible_v<T, optional<U>&>, is_constructible_v<T, optional<U>&&>, is_constructible_v<T, const optional<U>&>is_constructible_v<T, const optional<U>&&>is_convertible_v<optional<U>&, T>is_convertible_v<optional<U>&&, T>is_convertible_v<const optional<U>&, T> y is_convertible_v<const optional<U>&&, T> sean todos false.

~optional (destructor)

Destruye el valor contenido, si hay uno presente.

~optional();

Comentarios

Si T es trivialmente destructible, optional<T> también es trivialmente destructible.

operator=

Reemplaza el valor contenido de un objeto optional por una copia o movimiento de otro valor contenido de optional.

optional& operator=(nullopt_t) noexcept;
optional& operator=(const optional& rhs);
optional& operator=(optional&&) noexcept( /* see below */ );

template <class U = T>
    optional& operator=(U&&);

template <class U>
optional& operator=(const optional<U>&);

template <class U>
    optional& operator=(optional<U>&&);

template <class... Args>
T& emplace(Args&&...);

template <class U, class... Args>
T& emplace(initializer_list<U>, Args&&...);

operator->

Desreferencia el valor contenido de un objeto optional.

constexpr const T* operator->() const;
constexpr T* operator->();

operator*

Desreferencia el valor contenido de un objeto optional.

constexpr const T& operator*() const&;
constexpr T& operator*() &;
constexpr T&& operator*() &&;
constexpr const T&& operator*() const&&;

operator bool

Informa de si el objeto optional tiene un valor contenido.

constexpr explicit operator bool() const noexcept;

reset

De hecho, llama al destructor del objeto contenido, si existe, y lo establece en un estado no inicializado.

void reset() noexcept;

swap

template<class T>
void swap(optional<T>&, optional<T>&) noexcept;

value

constexpr const T& value() const&;
constexpr T& value() &;
constexpr T&& value() &&;
constexpr const T&& value() const&&;

value_or

template <class U>
    constexpr T value_or(U&&) const&;
template <class U>
    constexpr T value_or(U&&) &&;

Consulte también

<opcional>

  • Last updated on