This header is part of the general utility library.
[edit] Synopsis// mostly freestanding
#include <compare>
namespace std {
// class template optional
template<class T> class optional; // partially freestanding
template<class T> constexpr bool ranges::enable_view<optional<T>> = true;
template<class T> constexpr auto format_kind<optional<T>> = range_format::disabled;
template<class T>
concept /*is-derived-from-optional*/ = requires(const T& t) { // exposition-only
[]<class U>(const optional<U>&) {}(t);
};
// no-value state indicator
struct nullopt_t
{ /* see description */
};
inline constexpr nullopt_t nullopt(/* unspecified */);
// class bad_optional_access
class bad_optional_access;
// relational operators
template<class T, class U>
constexpr bool operator==(const optional<T>&, const optional<U>&);
template<class T, class U>
constexpr bool operator!=(const optional<T>&, const optional<U>&);
template<class T, class U>
constexpr bool operator<(const optional<T>&, const optional<U>&);
template<class T, class U>
constexpr bool operator>(const optional<T>&, const optional<U>&);
template<class T, class U>
constexpr bool operator<=(const optional<T>&, const optional<U>&);
template<class T, class U>
constexpr bool operator>=(const optional<T>&, const optional<U>&);
template<class T, three_way_comparable_with<T> U>
constexpr compare_three_way_result_t<T, U> operator<=>(const optional<T>&,
const optional<U>&);
// comparison with nullopt
template<class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept;
template<class T>
constexpr strong_ordering operator<=>(const optional<T>&, nullopt_t) noexcept;
// comparison with T
template<class T, class U> constexpr bool operator==(const optional<T>&, const U&);
template<class T, class U> constexpr bool operator==(const T&, const optional<U>&);
template<class T, class U> constexpr bool operator!=(const optional<T>&, const U&);
template<class T, class U> constexpr bool operator!=(const T&, const optional<U>&);
template<class T, class U> constexpr bool operator<(const optional<T>&, const U&);
template<class T, class U> constexpr bool operator<(const T&, const optional<U>&);
template<class T, class U> constexpr bool operator>(const optional<T>&, const U&);
template<class T, class U> constexpr bool operator>(const T&, const optional<U>&);
template<class T, class U> constexpr bool operator<=(const optional<T>&, const U&);
template<class T, class U> constexpr bool operator<=(const T&, const optional<U>&);
template<class T, class U> constexpr bool operator>=(const optional<T>&, const U&);
template<class T, class U> constexpr bool operator>=(const T&, const optional<U>&);
template<class T, class U>
requires(!/*is-derived-from-optional*/<U>) && three_way_comparable_with<T, U>
constexpr compare_three_way_result_t<T, U> operator<=>(const optional<T>&, const U&);
// specialized algorithms
template<class T>
constexpr void swap(optional<T>&, optional<T>&) noexcept(/* see description */);
template<class T> constexpr optional<decay_t<T>> make_optional(T&&);
template<class T, class... Args> constexpr optional<T> make_optional(Args&&... args);
template<class T, class U, class... Args>
constexpr optional<T> make_optional(initializer_list<U> il, Args&&... args);
// hash support
template<class T> struct hash;
template<class T> struct hash<optional<T>>;
}[edit] Class template std::optional
namespace std {
template<class T> class optional
{
public:
using value_type = T;
using iterator = /* implementation-defined */;
using const_iterator = /* implementation-defined */;
// constructors
constexpr optional() noexcept;
constexpr optional(nullopt_t) noexcept;
constexpr optional(const optional&);
constexpr optional(optional&&) noexcept(/* see description */);
template<class... Args> constexpr explicit optional(in_place_t, Args&&...);
template<class U, class... Args>
constexpr explicit optional(in_place_t, initializer_list<U>, Args&&...);
template<class U = remove_cv_t<T>>
constexpr explicit(/* see description */) optional(U&&);
template<class U>
constexpr explicit(/* see description */) optional(const optional<U>&);
template<class U> constexpr explicit(/* see description */) optional(optional<U>&&);
// destructor
constexpr ~optional();
// assignment
constexpr optional& operator=(nullopt_t) noexcept;
constexpr optional& operator=(const optional&);
constexpr optional& operator=(optional&&) noexcept(/* see description */);
template<class U = remove_cv_t<T>> constexpr optional& operator=(U&&);
template<class U> constexpr optional& operator=(const optional<U>&);
template<class U> constexpr optional& operator=(optional<U>&&);
template<class... Args> constexpr T& emplace(Args&&...);
template<class U, class... Args> constexpr T& emplace(initializer_list<U>, Args&&...);
// swap
constexpr void swap(optional&) noexcept(/* see description */);
// iterator support
constexpr iterator begin() noexcept;
constexpr const_iterator begin() const noexcept;
constexpr iterator end() noexcept;
constexpr const_iterator end() const noexcept;
// observers
constexpr const T* operator->() const noexcept;
constexpr T* operator->() noexcept;
constexpr const T& operator*() const& noexcept;
constexpr T& operator*() & noexcept;
constexpr T&& operator*() && noexcept;
constexpr const T&& operator*() const&& noexcept;
constexpr explicit operator bool() const noexcept;
constexpr bool has_value() const noexcept;
constexpr const T& value() const&; // freestanding-deleted
constexpr T& value() &; // freestanding-deleted
constexpr T&& value() &&; // freestanding-deleted
constexpr const T&& value() const&&; // freestanding-deleted
template<class U = remove_cv_t<T>> constexpr T value_or(U&&) const&;
template<class U = remove_cv_t<T>> constexpr T value_or(U&&) &&;
// monadic operations
template<class F> constexpr auto and_then(F&& f) &;
template<class F> constexpr auto and_then(F&& f) &&;
template<class F> constexpr auto and_then(F&& f) const&;
template<class F> constexpr auto and_then(F&& f) const&&;
template<class F> constexpr auto transform(F&& f) &;
template<class F> constexpr auto transform(F&& f) &&;
template<class F> constexpr auto transform(F&& f) const&;
template<class F> constexpr auto transform(F&& f) const&&;
template<class F> constexpr optional or_else(F&& f) &&;
template<class F> constexpr optional or_else(F&& f) const&;
// modifiers
constexpr void reset() noexcept;
private:
T* val; // exposition-only
};
template<class T> optional(T) -> optional<T>;
}[edit] Class template std::bad_optional_access
namespace std {
class bad_optional_access : public exception
{
public:
// for the specification of the special member functions
constexpr const char* what() const noexcept override;
};
}
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4