std::experimental::optional

From cppreference.com
 
 
Technical specifications
Filesystem library (filesystem TS)
Library fundamentals (library fundamentals TS)
Library fundamentals 2 (library fundamentals TS v2)
Library fundamentals 3 (library fundamentals TS v3)
Extensions for parallelism (parallelism TS)
Extensions for parallelism 2 (parallelism TS v2)
Extensions for concurrency (concurrency TS)
Extensions for concurrency 2 (concurrency TS v2)
Concepts (concepts TS)
Ranges (ranges TS)
Reflection (reflection TS)
Mathematical special functions (special functions TR)
 
 
 
Defined in header <experimental/optional>
template< class T >
class optional;
(library fundamentals TS)

The class template std::experimental::optional manages an optional contained value, i.e. a value that may or may not be present.

A common use case for optional is the return value of a function that may fail. As opposed to other approaches, such as std::pair<T,bool>, optional handles expensive to construct objects well and is more readable, as the intent is expressed explicitly.

Any instance of optional<T> at any given point in time either contains a value or does not contain a value.

If an optional<T> contains a value, the value is guaranteed to be allocated as part of the optional object footprint, i.e. no dynamic memory allocation ever takes place. Thus, an optional object models an object, not a pointer, even though the operator*() and operator->() are defined.

When an object of type optional<T> is contextually converted to bool, the conversion returns true if the object contains a value and false if it does not contain a value.

The optional object contains a value in the following conditions:

  • The object is initialized with a value of type T.
  • The object is assigned from another optional that contains a value.

The object does not contain a value in the following conditions:

  • The object is default-initialized.
  • The object is initialized with a value of std::experimental::nullopt_t or an optional object that does not contain a value.
  • The object is assigned from a value of std::experimental::nullopt_t or from an optional that does not contain a value.

Template parameters

T - the type of the value to manage initialization state for. The type must meet the requirements of Destructible.

Member types

Member type Definition
value_type T

Member functions

constructs the optional object
(public member function)
destroys the contained value, if there is one
(public member function)
assigns contents
(public member function)
Observers
accesses the contained value
(public member function)
checks whether the object contains a value
(public member function)
returns the contained value
(public member function)
returns the contained value if available, another value otherwise
(public member function)
Modifiers
exchanges the contents
(public member function)
constructs the contained value in-place
(public member function)

Member objects

Member name Definition
val (private) pointer to the contained value (which points at a data member of the same object), the name is for exposition only

Non-member functions

compares optional objects
(function template)
creates an optional object
(function template)
specializes the std::swap algorithm
(function)

Helper classes

specializes the std::hash algorithm
(class template specialization)
(library fundamentals TS)
indicator of optional type with uninitialized state
(class)
(library fundamentals TS)
disambiguation tag type for in-place construction of optional types
(class)
(library fundamentals TS)
exception indicating checked access to an optional that doesn't contain a value
(class)

Helper objects

(library fundamentals TS)
an object of type nullopt_t
(function)
(library fundamentals TS)
an object of type std::experimental::in_place_t
(function)