optional – třída

Šablona optional<T> třídy popisuje objekt, který může nebo nemusí obsahovat hodnotu typu T, která se označuje jako obsažená hodnota.

Pokud instance optional<T> obsahuje hodnotu, je obsažená hodnota přidělena v rámci úložiště optional objektu, v oblasti vhodně zarovnané pro typ T. Při převodu optional<T> na boolvýsledek je true , pokud objekt obsahuje hodnotu; v opačném případě je falseto .

Obsažený typ T objektu nesmí být in_place_t nebo nullopt_t. T musí být destruktivovatelný, to znamená, že jeho destruktor musí uvolnit všechny vlastněné prostředky a nesmí vyvolat žádné výjimky.

Třída optional je v jazyce C++17 nová.

Syntaxe

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

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

Členové

Konstruktory

Název	Popis
Konstruktory a destruktor
optional	Vytvoří objekt typu optional.
~volitelný	Zničí objekt typu optional.
Přiřazení
operator=	optional Nahradí kopii jiného optionalsouboru .
umístit	Inicializuje hodnotu obsaženou se zadanými argumenty.
Vyměnit
vyměnit	Prohodí obsaženou hodnotu nebo prázdný stav s jiným optional.
Pozorovatelé
has_value	Vrátí, zda optional objekt obsahuje hodnotu.
value	Vrátí hodnotu obsaženou.
value_or	Vrátí hodnotu obsaženou nebo alternativu, pokud neexistuje žádná hodnota.
operátor->	Odkazuje na obsaženou hodnotu objektu optional .
operátor*	Odkazuje na obsaženou hodnotu objektu optional .
bool – operátor	Vrátí, zda optional objekt obsahuje hodnotu.
Modifikátory
resetovat	optional Obnoví hodnotu zničením jakékoli obsažené hodnoty.

has_value

constexpr bool has_value() const noexcept;

volitelný konstruktor

Vytvoří objekt typu 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);

Parametry

rhs
Možnost optional kopírování nebo přesunutí vytvoří hodnotu obsaženou z.

i_list
Seznam inicializátoru pro vytvoření obsažené hodnoty z.

args
Seznam argumentů pro vytvoření obsažené hodnoty z.

Poznámky

constexpr optional() noexcept;constexpr optional(nullopt_t nullopt) noexcept; Tyto konstruktory vytvoří hodnotu optional , která neobsahuje hodnotu.

constexpr optional(const optional& rhs); Konstruktor copy inicializuje obsaženou hodnotu z obsažené hodnoty argumentu. Je definován jako odstraněný , pokud is_copy_constructible_v<T> není pravdivý, a pokud je pravdivý, je triviální is_trivially_copy_constructible_v<T> .

constexpr optional(optional&& rhs) noexcept; Konstruktor přesunutí inicializuje obsaženou hodnotu přesunutím z obsažené hodnoty argumentu. Není součástí řešení přetížení, pokud is_move_constructible_v<T> není pravda, a to je triviální, pokud is_trivially_move_constructible_v<T> je pravda.

template <class... Args> constexpr explicit optional(in_place_t, Args&&... args); Přímo inicializuje obsaženou hodnotu, jako by používal argumenty std::forward<Args>(args). Tento konstruktor je constexpr , pokud T je constexprpoužit konstruktor . Není součástí řešení přetížení, pokud is_constructible_v<T, Args...> není pravdivý.

template <class U, class... Args> constexpr explicit optional(in_place_t, initializer_list<U> i_list, Args&&... args); Přímo inicializuje obsaženou hodnotu, jako by používal argumenty i_list, std::forward<Args>(args). Tento konstruktor je constexpr , pokud T je constexprpoužit konstruktor . Není součástí řešení přetížení, pokud is_constructible_v<T, initializer_list<U>&, Args&&...> není pravdivý.

template <class U = T> explicit constexpr optional(U&& rhs); Direct initializes thecontained value as if if using std::forward<U>(v). Tento konstruktor je constexpr , pokud T je constexprpoužit konstruktor . Není součástí řešení přetížení, pokud is_constructible_v<T, U&&> není pravda a is_same_v<remove_cvref_t<U>, in_place_t> is_same_v<remove_cvref_t<U>, optional> nejsou false.

template <class U> explicit optional(const optional<U>& rhs); Pokud rhs obsahuje hodnotu, direct initializes thecontained value from thecontained value of the argument. Není součástí řešení přetížení, pokud is_constructible_v<T, const U&> není true, a 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>a is_convertible_v<const optional<U>&&, T> jsou všechny false.

template <class U> explicit optional(optional<U>&& rhs); Pokud rhs obsahuje hodnotu, přímo inicializuje obsaženou hodnotu, jako kdybyste používali std::move(*rhs). Není součástí řešení přetížení, pokud is_constructible_v<T, U&&> není true, a 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>a is_convertible_v<const optional<U>&&, T> jsou všechny false.

~volitelný destruktor

Zničí obsaženou hodnotu, pokud existuje.

~optional();

Poznámky

Pokud T je triviálně destrukovatelný, je také optional<T> triviálně destrukovatelný.

operator=

Nahradí obsaženou hodnotu kopie optional nebo se přesune z jiné optional obsažené hodnoty.

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

operátor->

Dereferences obsažené hodnoty objektu optional .

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

operátor*

Dereferences obsažené hodnoty objektu optional .

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

bool – operátor

Zaznamenává, zda optional má objekt hodnotu obsaženou.

constexpr explicit operator bool() const noexcept;

resetování

Efektivně volá destruktor obsaženého objektu, pokud existuje, a nastaví ho na neinicializovaný stav.

void reset() noexcept;

swap

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

hodnota

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

Viz také

<optional>