std::experimental::optional

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

 

Experimental libraries

Experimental standard libraries

optional (library fundamentals TS)

any (library fundamentals TS)

basic_string_view (library fundamentals TS)

Polymorphic allocator library (library fundamentals TS)

Filesystem library (filesystem TS)

 

std::experimental::optional

Member functions

optional::optional

optional::~optional

optional::operator=

Observers

optional::operator->optional::operator*

optional::operator bool

optional::value

optional::value_or

Modifiers

optional::emplace

optional::swap

Non-member functions

operator==operator<

make_optional

swap

Helper classes

hash

 

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 semantically 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.

The value is guaranteed to be allocated within the optional object itself, 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.

The value inside an optional object may be in either an initialized or uninitialized state. An optional object with a value in initialized state is called engaged, whereas if the value is in uninitialized state, the object is called disengaged.

The optional object is engaged on the following conditions:

• The object is initialized with a value of type T

• The object is assigned an engaged optional.

The object is disengaged on the following conditions:

• The object is default-initialized.

• The object is initialized with a value of std::experimental::nullopt_t or a disengaged optional object.

• The object is assigned a value of std::experimental::nullopt_t or a disengaged optional.

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

(constructor)	constructs the optional object (public member function)
(destructor)	if engaged, destroys the contained value (public member function)
operator=	assigns contents (public member function)
Observers
operator->operator*	accesses the contained value (public member function)
operator bool	checks whether the object is in engaged state (public member function)
value	returns the contained value (public member function)
value_or	returns the contained value if engaged, another value otherwise (public member function)
Modifiers
swap	exchanges the contents (public member function)
emplace	constructs the contained value in-place (public member function)

Non-member functions

operator==operator<	compares optional objects (function template)
make_optional	creates an optional object (function template)
std::swap(std::experimental::optional)	specializes the std::swap algorithm (function)

Helper classes

std::hash<std::experimental::optional>

specializes the std::hash algorithm (class template specialization)