Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
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&&) &&;