Partager via

facultatif, classe

Le modèle optional<T> de classe décrit un objet qui peut contenir ou non une valeur de type T, appelée valeur contenue.

Lorsqu’une instance de optional<T> contient une valeur, la valeur contenue est allouée dans le stockage de l’objet optional , dans une région alignée de manière adaptée au type T. Lorsqu’un optional<T> objet est converti boolen , le résultat est true si l’objet contient une valeur ; sinon, il s’agit false.

Le type T d’objet contenu ne doit pas être in_place_t ou nullopt_t. T doit être destructeur, autrement dit, son destructeur doit récupérer toutes les ressources détenues et ne peut lever aucune exception.

La optional classe est nouvelle en C++17.

Syntaxe

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

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

Membres

Constructeurs

Nom Description
Constructeurs et destructeurs
facultatif Construit un objet de type optional.
~optionnel Détruit un objet de type optional.
Affectation
operator= Remplace le optional par une copie d’un autre optional.
emplace Initialise la valeur contenue avec des arguments spécifiés.
Swap
swap Échange la valeur contenue ou l’état vide par un autre optional.
Observateurs
has_value Retourne si un optional objet contient une valeur.
valeur Retourne la valeur contenue.
value_or Retourne la valeur contenue ou une alternative si aucune valeur n’est présente.
operator-> Fait référence à la valeur contenue d’un optional objet.
operator* Fait référence à la valeur contenue d’un optional objet.
operator bool Retourne si un optional objet contient une valeur.
Modificateurs
reset Réinitialise en optional détruisant n’importe quelle valeur contenue.

has_value

constexpr bool has_value() const noexcept;

constructeur facultatif

Construit un objet de type 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);

Paramètres

rhs
À optional partir duquel copier ou déplacer la valeur contenue.

i_list
Liste d’initialiseurs à partir duquel construire la valeur contenue.

args
Liste d’arguments à partir duquel construire la valeur contenue.

Notes

constexpr optional() noexcept;constexpr optional(nullopt_t nullopt) noexcept; Ces constructeurs construisent un optional constructeur qui ne contient pas de valeur.

constexpr optional(const optional& rhs); Le constructeur de copie initialise la valeur contenue à partir de la valeur contenue de l’argument. Elle est définie comme supprimée , sauf si is_copy_constructible_v<T> elle est vraie, et elle est triviale si is_trivially_copy_constructible_v<T> elle est vraie.

constexpr optional(optional&& rhs) noexcept; Le constructeur de déplacement initialise la valeur contenue en passant de la valeur contenue de l’argument. Il ne participe pas à la résolution de surcharge, sauf s’il is_move_constructible_v<T> est vrai, et c’est trivial si is_trivially_move_constructible_v<T> c’est vrai.

template <class... Args> constexpr explicit optional(in_place_t, Args&&... args); Initialise directement la valeur contenue comme si vous utilisez les arguments std::forward<Args>(args). Ce constructeur est constexpr si le T constructeur utilisé est constexpr. Elle ne participe pas à la résolution de surcharge, sauf si is_constructible_v<T, Args...> elle est vraie.

template <class U, class... Args> constexpr explicit optional(in_place_t, initializer_list<U> i_list, Args&&... args); Initialise directement la valeur contenue comme si vous utilisez les arguments i_list, std::forward<Args>(args). Ce constructeur est constexpr si le T constructeur utilisé est constexpr. Elle ne participe pas à la résolution de surcharge, sauf si is_constructible_v<T, initializer_list<U>&, Args&&...> elle est vraie.

template <class U = T> explicit constexpr optional(U&& rhs); Initialise directement la valeur contenue comme si vous utilisez std::forward<U>(v). Ce constructeur est constexpr si le T constructeur utilisé est constexpr. Il ne participe pas à la résolution de surcharge, sauf s’il is_constructible_v<T, U&&> est vrai et is_same_v<remove_cvref_t<U>, in_place_t> is_same_v<remove_cvref_t<U>, optional> est faux.

template <class U> explicit optional(const optional<U>& rhs); Si rhs contient une valeur, initialise directement la valeur contenue à partir de la valeur contenue de l’argument. Elle ne participe pas à la résolution de surcharge, sauf si is_constructible_v<T, const U&> elle est vraie, et 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>et is_convertible_v<const optional<U>&&, T> est toutes false.

template <class U> explicit optional(optional<U>&& rhs); Si rhs contient une valeur, initialise directement la valeur contenue comme si vous utilisez std::move(*rhs). Elle ne participe pas à la résolution de surcharge, sauf si is_constructible_v<T, U&&> elle est vraie, et 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>et is_convertible_v<const optional<U>&&, T> est toutes false.

~destructeur facultatif

Détruit la valeur contenue, si elle est présente.

~optional();

Notes

S’il T est trivialement destructeur, il optional<T> est également destructible de manière triviale.

opérateur =

Remplace la valeur contenue d’une optional copie ou d’un déplacement d’une autre optional valeur contenue.

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

opérateur->

Déréférence la valeur contenue d’un optional objet.

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

operator*

Déréférence la valeur contenue d’un optional objet.

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

operator bool

Indique si l’objet optional a une valeur contenue.

constexpr explicit operator bool() const noexcept;

reset

En fait, appelle le destructeur de l’objet contenu, le cas échéant, et le définit à un état non initialisé.

void reset() noexcept;

swap

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

valeur

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

Voir aussi

<facultatif>

  • Last updated on