Experimental library header <experimental/optional>

From cppreference.com

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros(C++20)
Language support library
Concepts library(C++20)
Diagnostics library
Memory management library
Metaprogramming library(C++11)
General utilities library
Containers library
Iterators library
Ranges library(C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library(C++17)
Concurrency support library(C++11)
Execution control library(C++26)
Technical specifications
Symbols index
External libraries

[edit]

Standard library headers

Language support
`<cfloat>`
`<climits>`
`<compare>`(C++20)
`<contracts>`(C++26)
`<coroutine>`(C++20)
`<csetjmp>`
`<csignal>`
`<cstdarg>`
`<cstddef>`
`<cstdint>`(C++11)
`<cstdlib>`
`<exception>`
`<initializer_list>`(C++11)
`<limits>`
`<new>`
`<source_location>`(C++20)
`<stdfloat>`(C++23)
`<typeinfo>`
`<version>`(C++20)
Concepts
`<concepts>`(C++20)
Diagnostics
`<cassert>`
`<cerrno>`
`<debugging>`(C++26)
`<stacktrace>`(C++23)
`<stdexcept>`
`<system_error>`(C++11)
Memory management
`<memory>`
`<memory_resource>`(C++17)
`<scoped_allocator>`(C++11)
Metaprogramming
`<type_traits>`(C++11)
`<ratio>`(C++11)

General utilities
`<any>`(C++17)
`<bitset>`
`<bit>`(C++20)
`<charconv>`(C++17)
`<expected>`(C++23)
`<format>`(C++20)
`<functional>`
`<optional>`(C++17)
`<stdbit.h>`(C++26)
`<tuple>`(C++11)
`<typeindex>`(C++11)
`<utility>`
`<variant>`(C++17)
Containers
`<array>`(C++11)
`<deque>`
`<flat_map>`(C++23)
`<flat_set>`(C++23)
`<forward_list>`(C++11)
`<hive>`(C++26)
`<inplace_vector>`(C++26)
`<list>`
`<map>`
`<mdspan>`(C++23)
`<queue>`
`<set>`
`<span>`(C++20)
`<stack>`
`<unordered_map>`(C++11)
`<unordered_set>`(C++11)
`<vector>`
Iterators
`<iterator>`
Ranges
`<generator>`(C++23)
`<ranges>`(C++20)

Algorithms
`<algorithm>`
`<numeric>`
Strings
`<cctype>`
`<cstring>`
`<cuchar>`(C++11)
`<cwchar>`
`<cwctype>`
`<string_view>`(C++17)
`<string>`
Text processing
`<clocale>`
`<codecvt>`(C++11/17/26*)
`<locale>`
`<regex>`(C++11)
`<text_encoding>`(C++26)
Numerics
`<cfenv>`(C++11)
`<cmath>`
`<complex>`
`<linalg>`(C++26)
`<numbers>`(C++20)
`<random>`(C++11)
`<simd>`(C++26)
`<stdckdint.h>`(C++26)
`<valarray>`
Time
`<chrono>`(C++11)
`<ctime>`
C compatibility
`<ccomplex>`(C++11/17/20*)
`<ciso646>`(until C++20)
`<cstdalign>`(C++11/17/20*)
`<cstdbool>`(C++11/17/20*)
`<ctgmath>`(C++11/17/20*)

Input/output
`<cinttypes>`(C++11)
`<cstdio>`
`<filesystem>`(C++17)
`<fstream>`
`<iomanip>`
`<iosfwd>`
`<iostream>`
`<ios>`
`<istream>`
`<ostream>`
`<print>`(C++23)
`<spanstream>`(C++23)
`<sstream>`
`<streambuf>`
`<strstream>`(C++98/26*)
`<syncstream>`(C++20)
Concurrency support
`<atomic>`(C++11)
`<barrier>`(C++20)
`<condition_variable>`(C++11)
`<future>`(C++11)
`<hazard_pointer>`(C++26)
`<latch>`(C++20)
`<mutex>`(C++11)
`<rcu>`(C++26)
`<semaphore>`(C++20)
`<shared_mutex>`(C++14)
`<stdatomic.h>`(C++23)
`<stop_token>`(C++20)
`<thread>`(C++11)
Execution support
`<execution>`(C++17)

[edit]

Experimental library headers

ExecutionP2300

<experimental/execution>

Filesystem TS

<experimental/filesystem>

Parallelism TS (v1, v2)

`experimental/algorithm`
`experimental/execution_policy`
`experimental/exception_list`

`experimental/numeric`
`<experimental/simd>`
`experimental/task_block`

Library Fundamentals TS (v1, v2, v3)

`experimental/algorithm`
`<experimental/any>`
`experimental/array`
`experimental/chrono`
`experimental/deque`
`experimental/forward_list`
`<experimental/functional>`
`experimental/future`
`experimental/iterator`
`experimental/list`
`experimental/map`
`experimental/memory`
`<experimental/memory_resource>`
`experimental/numeric`
`<experimental/optional>`
`experimental/propagate_const`

`experimental/random`
`experimental/ratio`
`experimental/regex`
`experimental/scope`
`experimental/set`
`experimental/source_location`
`experimental/string`
`<experimental/string_view>`
`experimental/system_error`
`experimental/tuple`
`experimental/type_traits`
`experimental/unordered_map`
`experimental/unordered_set`
`experimental/utility`
`experimental/vector`

Concurrency TS

`experimental/atomic`
`experimental/barrier`

`experimental/future`
`experimental/latch`

Ranges TS

`<experimental/ranges/algorithm>`
`<experimental/ranges/concepts>`
`<experimental/ranges/functional>`
`<experimental/ranges/iterator>`

`<experimental/ranges/random>`
`<experimental/ranges/tuple>`
`<experimental/ranges/type_traits>`
`<experimental/ranges/utility>`

Coroutines TS

experimental/coroutine

Networking TS

`experimental/buffer`
`experimental/executor`
`experimental/internet`
`experimental/io_context`

`<experimental/net>`
`experimental/netfwd`
`experimental/socket`
`experimental/timer`

Reflection TS

<experimental/reflect>

[edit]

This header is part of the Library Fundamentals TS (v1,v2).

[edit]Classes

Name	Description
optional (library fundamentals TS)	a wrapper that may or may not hold an object (class template)[edit]
bad_optional_access (library fundamentals TS)	exception indicating checked access to an optional that doesn't contain a value (class)[edit]
in_place_t (library fundamentals TS)	disambiguation tag type for in-place construction of optional types (class)[edit]
std::hash<std::experimental::optional>	specializes thestd::hash algorithm (class template specialization)[edit]
nullopt_t (library fundamentals TS)	indicator of optional type with uninitialized state (class)[edit]

[edit]Functions

Comparison
operator==operator!=operator<operator<=operator>operator>=	compares`optional` objects (function template)[edit]
Specialized algorithms
std::swap(std::experimental::optional)	specializes thestd::swap algorithm (function)[edit]
make_optional	creates an`optional` object (function template)[edit]
Hash support

[edit]Synopsis

namespace std{namespace experimental{inlinenamespace fundamentals_v1{ // 5.4, optional for object typestemplate<class T>class optional; // 5.5, In-place constructionstruct in_place_t{};constexpr in_place_t in_place{}; // 5.6, Disengaged state indicatorstruct nullopt_t{see below};constexpr nullopt_t nullopt(unspecified); // 5.7, Class bad_optional_accessclass bad_optional_access; // 5.8, Relational operatorstemplate<class T>constexprbool operator==(const optional<T>&,const optional<T>&);template<class T>constexprbool operator!=(const optional<T>&,const optional<T>&);template<class T>constexprbool operator<(const optional<T>&,const optional<T>&);template<class T>constexprbool operator>(const optional<T>&,const optional<T>&);template<class T>constexprbool operator<=(const optional<T>&,const optional<T>&);template<class T>constexprbool operator>=(const optional<T>&,const optional<T>&); // 5.9, Comparison with nullopttemplate<class T>constexprbool operator==(const optional<T>&, nullopt_t)noexcept;template<class T>constexprbool operator==(nullopt_t,const optional<T>&)noexcept;template<class T>constexprbool operator!=(const optional<T>&, nullopt_t)noexcept;template<class T>constexprbool operator!=(nullopt_t,const optional<T>&)noexcept;template<class T>constexprbool operator<(const optional<T>&, nullopt_t)noexcept;template<class T>constexprbool operator<(nullopt_t,const optional<T>&)noexcept;template<class T>constexprbool operator<=(const optional<T>&, nullopt_t)noexcept;template<class T>constexprbool operator<=(nullopt_t,const optional<T>&)noexcept;template<class T>constexprbool operator>(const optional<T>&, nullopt_t)noexcept;template<class T>constexprbool operator>(nullopt_t,const optional<T>&)noexcept;template<class T>constexprbool operator>=(const optional<T>&, nullopt_t)noexcept;template<class T>constexprbool operator>=(nullopt_t,const optional<T>&)noexcept; // 5.10, Comparison with Ttemplate<class T>constexprbool operator==(const optional<T>&,const T&);template<class T>constexprbool operator==(const T&,const optional<T>&);template<class T>constexprbool operator!=(const optional<T>&,const T&);template<class T>constexprbool operator!=(const T&,const optional<T>&);template<class T>constexprbool operator<(const optional<T>&,const T&);template<class T>constexprbool operator<(const T&,const optional<T>&);template<class T>constexprbool operator<=(const optional<T>&,const T&);template<class T>constexprbool operator<=(const T&,const optional<T>&);template<class T>constexprbool operator>(const optional<T>&,const T&);template<class T>constexprbool operator>(const T&,const optional<T>&);template<class T>constexprbool operator>=(const optional<T>&,const T&);template<class T>constexprbool operator>=(const T&,const optional<T>&); // 5.11, Specialized algorithmstemplate<class T>void swap(optional<T>&, optional<T>&)noexcept(see below);template<class T>constexpr optional<see below> make_optional(T&&); }// namespace fundamentals_v1}// namespace experimental // 5.12, Hash supporttemplate<class T>struct hash;template<class T>struct hash<experimental::optional<T>>; }// namespace std