Teilen über

optionale Klasse

Die Klassenvorlage optional<T> beschreibt ein Objekt, das einen Wert vom Typ Tenthalten kann oder nicht enthält, der als enthaltener Wert bezeichnet wird.

Wenn eine Instanz eines optional<T> Werts enthält, wird der enthaltene Wert innerhalb des Speichers des optional Objekts zugeordnet, in einem Bereich, der entsprechend für den Typ Tausgerichtet ist. Wenn ein optional<T> Objekt konvertiert boolwird, lautet true das Ergebnis, wenn das Objekt einen Wert enthält; andernfalls ist falsees .

Der enthaltene Objekttyp T darf nicht sein in_place_t oder nullopt_t. Tmuss destruktierbar sein, d. h. der Destruktor muss alle eigenen Ressourcen zurückfordern und kann keine Ausnahmen auslösen.

Die optional Klasse ist neu in C++17.

Syntax

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

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

Member

Konstruktoren

Name Beschreibung
Konstruktoren und Destruktor
optional Konstruiert ein Objekt vom Typ optional.
~wahlfrei Zerstört ein Objekt vom Typ optional.
Abtretung
operator= Ersetzt die optional Kopie einer anderen optional.
emplace Initialisiert den enthaltenen Wert mit angegebenen Argumenten.
Swap
swap Tauscht den enthaltenen Wert oder den leeren Zustand durch einen anderen optional.
Beobachter
has_value Gibt zurück, ob ein optional Objekt einen Wert enthält.
value Gibt den enthaltenen Wert zurück.
value_or Gibt den enthaltenen Wert oder eine Alternative zurück, wenn kein Wert vorhanden ist.
operator-> Verweist auf den enthaltenen Wert eines optional Objekts.
operator* Verweist auf den enthaltenen Wert eines optional Objekts.
operator bool Gibt zurück, ob ein optional Objekt einen Wert enthält.
Modifizierer
reset Setzt die optional zurück, indem alle enthaltenen Werte zerstört werden.

has_value

constexpr bool has_value() const noexcept;

optionaler Konstruktor

Konstruiert ein Objekt vom Typ 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);

Parameter

rhs
Das optional zu kopierende oder verschiebende Konstrukt des enthaltenen Werts.

i_list
Die Initialisierungsliste, aus der der enthaltene Wert erstellt werden soll.

args
Die Argumentliste, aus der der enthaltene Wert erstellt werden soll.

Hinweise

constexpr optional() noexcept;constexpr optional(nullopt_t nullopt) noexcept; Diese Konstruktoren erstellen einen optional Wert, der keinen Wert enthält.

constexpr optional(const optional& rhs); Der Kopierkonstruktor initialisiert den enthaltenen Wert aus dem enthaltenen Wert des Arguments. Es wird als gelöscht definiert, es sei denn is_copy_constructible_v<T> , es ist wahr, und es ist trivial, wenn is_trivially_copy_constructible_v<T> er wahr ist.

constexpr optional(optional&& rhs) noexcept; Der Verschiebungskonstruktor initialisiert den enthaltenen Wert, indem er aus dem enthaltenen Wert des Arguments wechselt. Es nimmt nicht an der Überladungsauflösung teil, es sei denn is_move_constructible_v<T> , es ist wahr, und es ist trivial, wenn is_trivially_move_constructible_v<T> dies zutrifft.

template <class... Args> constexpr explicit optional(in_place_t, Args&&... args); Der enthaltene Wert wird direkt initialisiert, als ob die Argumente std::forward<Args>(args)verwendet werden. Dieser Konstruktor ist constexpr , wenn der T verwendete constexprKonstruktor . Sie nimmt nicht an der Überladungsauflösung teil, es sei denn is_constructible_v<T, Args...> , sie ist wahr.

template <class U, class... Args> constexpr explicit optional(in_place_t, initializer_list<U> i_list, Args&&... args); Der enthaltene Wert wird direkt initialisiert, als ob die Argumente i_list, std::forward<Args>(args)verwendet werden. Dieser Konstruktor ist constexpr , wenn der T verwendete constexprKonstruktor . Sie nimmt nicht an der Überladungsauflösung teil, es sei denn is_constructible_v<T, initializer_list<U>&, Args&&...> , sie ist wahr.

template <class U = T> explicit constexpr optional(U&& rhs); Direct initialisiert den enthaltenen Wert so, als ob er verwendet std::forward<U>(v)wird. Dieser Konstruktor ist constexpr , wenn der T verwendete constexprKonstruktor . Sie nimmt nicht an der Überladungsauflösung teil, es sei denn is_constructible_v<T, U&&> , sie ist wahr und is_same_v<remove_cvref_t<U>, in_place_t> is_same_v<remove_cvref_t<U>, optional> ist falsch.

template <class U> explicit optional(const optional<U>& rhs); Wenn rhs einen Wert enthält, initialisiert direct den enthaltenen Wert aus dem enthaltenen Wert des Arguments. Sie nimmt nicht an der Überlastungsauflösung teil, es sei denn is_constructible_v<T, const U&> , es ist wahr, und 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>und is_convertible_v<const optional<U>&&, T> sind alle falsch.

template <class U> explicit optional(optional<U>&& rhs); Wenn rhs einen Wert enthält, initialisiert direct den enthaltenen Wert so, als ob std::move(*rhs)er verwendet wird. Sie nimmt nicht an der Überlastungsauflösung teil, es sei denn is_constructible_v<T, U&&> , es ist wahr, und 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>und is_convertible_v<const optional<U>&&, T> sind alle falsch.

~optionaler Destruktor

Zerstört den enthaltenen Wert, falls vorhanden.

~optional();

Hinweise

Wenn T es trivial destruktierbar ist, ist dies optional<T> auch trivial destruktierbar.

operator =

Ersetzt den enthaltenen Wert einer optional Durchschrift durch eine Kopie oder den Wechsel von einem anderen optional enthaltenen Wert.

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->

Leitet den enthaltenen Wert eines optional Objekts ab.

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

operator*

Leitet den enthaltenen Wert eines optional Objekts ab.

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

operator bool

Gibt an, ob das optional Objekt einen enthaltenen Wert aufweist.

constexpr explicit operator bool() const noexcept;

reset

Ruft effektiv den Destruktor des enthaltenen Objekts auf, falls vorhanden, und legt ihn auf einen nicht initialisierten Zustand fest.

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

Siehe auch

<optional>

  • Last updated on