Classe opcional

O modelo de classe optional<T> descreve um objeto que pode ou não conter um valor de tipo T, conhecido como o valor contido.

Quando uma instância de optional<T> contém um valor, o valor contido é alocado dentro da armazenagem do objeto optional em uma região adequadamente alinhada para o tipo T. Quando um optional<T> for convertido para bool, o resultado será true se o objeto contiver um valor; caso contrário, será false.

O tipo T de objeto contido não deve ser in_place_t ou nullopt_t. T deve ser destrutível, ou seja, seu destruidor deve recuperar todos os próprios recursos e não pode gerar exceções.

A classe optional é nova em C++17.

Sintaxe

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

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

Membros

Construtores

Nome	Descrição
Construtores e destruidores
optional	Constrói um objeto do tipo optional.
~optional	Destrói um objeto do tipo optional.
Cessão
operator=	Substitui o optional por uma cópia de outro optional.
emplace	Inicializa o valor contido com argumentos especificados.
Swap
troca	Troca o valor contido ou o estado vazio por outro optional.
Observadores
has_value	Retorna caso um objeto optional contenha um valor.
value	Retorna o valor contido.
value_or	Retorna o valor contido ou uma alternativa se nenhum valor estiver presente.
operator->	Referencia o valor contido de um objeto optional.
operator*	Referencia o valor contido de um objeto optional.
operator bool	Retorna caso um objeto optional contenha um valor.
Modificadores
reset	Redefine o optional destruindo qualquer valor contido.

has_value

constexpr bool has_value() const noexcept;

construtor opcional

Constrói um objeto do 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
O optional para copiar ou mover o constructo do valor contido.

i_lista
A lista de inicializadores para o constructo do valor contido.

args
A lista de argumentos para o constructo do valor contido.

Comentários

constexpr optional() noexcept;constexpr optional(nullopt_t nullopt) noexcept; Esses construtores constroem um optional que não contém um valor.

constexpr optional(const optional& rhs); O construtor de cópia inicializa o valor contido a partir do valor contido do argumento. Ele é definido como excluído, a menos que is_copy_constructible_v<T> seja verdadeiro, e é trivial se is_trivially_copy_constructible_v<T> for verdadeiro.

constexpr optional(optional&& rhs) noexcept; O construtor de movimentação inicializa o valor contido mudando o valor contido do argumento. Ele não participa da resolução de sobrecarga, a menos que is_move_constructible_v<T> seja verdadeiro, e é trivial se is_trivially_move_constructible_v<T> for verdadeiro.

template <class... Args> constexpr explicit optional(in_place_t, Args&&... args); Inicializa diretamente o valor contido como se estivesse usando os argumentos std::forward<Args>(args). Esse construtor será constexpr se o construtor T utilizado for constexpr. Ele não participa da resolução de sobrecarga, a menos que is_constructible_v<T, Args...> seja verdadeiro.

template <class U, class... Args> constexpr explicit optional(in_place_t, initializer_list<U> i_list, Args&&... args); Inicializa diretamente o valor contido como se estivesse usando os argumentos i_list, std::forward<Args>(args). Esse construtor será constexpr se o construtor T utilizado for constexpr. Ele não participa da resolução de sobrecarga, a menos que is_constructible_v<T, initializer_list<U>&, Args&&...> seja verdadeiro.

template <class U = T> explicit constexpr optional(U&& rhs); Inicializa diretamente o valor contido como se estivesse usando std::forward<U>(v). Esse construtor será constexpr se o construtor T utilizado for constexpr. Ele não participa da resolução de sobrecarga, a menos que is_constructible_v<T, U&&> seja verdadeiro, e is_same_v<remove_cvref_t<U>, in_place_t> e is_same_v<remove_cvref_t<U>, optional> sejam falsos.

template <class U> explicit optional(const optional<U>& rhs); Se rhs contiver um valor, inicializará diretamente o valor contido a partir do valor contido do argumento. Ele não participa da resolução de sobrecarga, a menos que is_constructible_v<T, const U&> seja verdadeiro e 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> e is_convertible_v<const optional<U>&&, T> sejam falsos.

template <class U> explicit optional(optional<U>&& rhs); Se rhs contiver um valor, inicializará diretamente o valor contido como se estivesse usando std::move(*rhs). Ele não participa da resolução de sobrecarga, a menos que is_constructible_v<T, U&&> seja verdadeiro e 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> e is_convertible_v<const optional<U>&&, T> sejam falsos.

destruidor ~optional

Destrói o valor contido, se houver um.

~optional();

Comentários

Se T for trivialmente destrutível, então optional<T> também será trivialmente destrutível.

operator=

Substitui o valor contido de um optional por uma cópia ou movimentação de outro valor contido 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->

Referência ao valor contido de um objeto optional.

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

operator*

Referência ao valor contido de um objeto optional.

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

operator bool

Relata se o objeto optional tem um valor contido.

constexpr explicit operator bool() const noexcept;

reset

Efetivamente, chama o destruidor do objeto contido, se houver, e o define como um estado não inicializado.

void reset() noexcept;

troca

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&&) &&;

Confira também

<optional>