std::optional

 

C++

Compiler support

Freestanding and hosted

Language

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Technical specifications

Symbols index

External libraries

 

Utilities library

Language support Type support (basic types, RTTI) Library feature-test macros (C++20) Dynamic memory management Program utilities Coroutine support (C++20) Variadic functions is_constant_evaluated (C++20) launder (C++17) initializer_list (C++11) source_location (C++20) Three-way comparison (C++20) three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)    is_eqis_neqis_ltis_lteqis_gtis_gteq (C++20)(C++20)(C++20)(C++20)(C++20)(C++20)

General utilities Date and time Function objects Formatting library (C++20) bitset hash (C++11) Relational operators (deprecated in C++20) rel_ops::operator!=rel_ops::operator> rel_ops::operator<=rel_ops::operator>= Integer comparison functions cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)    cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap and type operations swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Common vocabulary types pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23) Elementary string conversions to_chars (C++17) from_chars (C++17) chars_format (C++17)

 

std::optional

Member functions

optional::optional (C++17)

optional::~optional (C++17)

optional::operator= (C++17)

Observers

optional::operator->optional::operator* (C++17)(C++17)

optional::operator booloptional::has_value (C++17)(C++17)

optional::value (C++17)

optional::value_or (C++17)

Monadic operations

optional::and_then (C++23)

optional::transform (C++23)

optional::or_else (C++23)

Modifiers

optional::emplace (C++17)

optional::swap (C++17)

optional::reset (C++17)

Non-member functions

operator==operator!=operator<operator<=operator>operator>=operator<=> (C++17)(C++17)(C++17)(C++17)(C++17)(C++17)(C++20)

make_optional (C++17)

swap (C++17)

Deduction guides

Helper classes

hash (C++17)

nullopt_t (C++17)

in_place_t (C++17)

bad_optional_access (C++17)

Helper objects

nullopt (C++17)

in_place (C++17)

 

Defined in header <optional>
template< class T > class optional;		(since C++17)

The class template std::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 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/assigned from a value of type T or 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/assigned from a value of type std::nullopt_t or an optional object that does not contain a value.
• The member function reset() is called.

There are no optional references; a program is ill-formed if it instantiates an optional with a reference type. Alternatively, an optional of a std::reference_wrapper of type T may be used to hold a reference. In addition, a program is ill-formed if it instantiates an optional with the (possibly cv-qualified) tag types std::nullopt_t or std::in_place_t.

Template parameters

T

-

the type of the value to manage initialization state for. The type must meet the requirements of Destructible (in particular, array and reference types are not allowed).

Member types

Member type	Definition
value_type	T

Member functions

(constructor)	constructs the optional object (public member function)
(destructor)	destroys the contained value, if there is one (public member function)
operator=	assigns contents (public member function)
Observers
operator->operator*	accesses the contained value (public member function)
operator boolhas_value	checks whether the object contains a value (public member function)
value	returns the contained value (public member function)
value_or	returns the contained value if available, another value otherwise (public member function)
Monadic operations
and_then (C++23)	returns the result of the given function on the contained value if it exists, or an empty optional otherwise (public member function)
transform (C++23)	returns an optional containing the transformed contained value if it exists, or an empty optional otherwise (public member function)
or_else (C++23)	returns the optional itself if it contains a value, or the result of the given function otherwise (public member function)
Modifiers
swap	exchanges the contents (public member function)
reset	destroys any contained value (public member function)
emplace	constructs the contained value in-place (public member function)

Non-member functions

operator==operator!=operator<operator<=operator>operator>=operator<=> (C++17)(C++17)(C++17)(C++17)(C++17)(C++17)(C++20)	compares optional objects (function template)
make_optional (C++17)	creates an optional object (function template)
std::swap(std::optional) (C++17)	specializes the std::swap algorithm (function template)

Helper classes

std::hash<std::optional> (C++17)	specializes the std::hash algorithm (class template specialization)
nullopt_t (C++17)	indicator of optional type with uninitialized state (class)
bad_optional_access (C++17)	exception indicating checked access to an optional that doesn't contain a value (class)

Helpers

nullopt (C++17)	an object of type nullopt_t (constant)
in_place in_place_type in_place_index in_place_t in_place_type_t in_place_index_t (C++17)	in-place construction tag (class template)

Notes

Feature-test macro:

__cpp_lib_optional

Example

Run this code

#include <string>
#include <functional>
#include <iostream>
#include <optional>
 
// optional can be used as the return type of a factory that may fail
std::optional<std::string> create(bool b) {
    if (b)
        return "Godzilla";
    return {};
}
 
// std::nullopt can be used to create any (empty) std::optional
auto create2(bool b) {
    return b ? std::optional<std::string>{"Godzilla"} : std::nullopt;
}
 
// std::reference_wrapper may be used to return a reference
auto create_ref(bool b) {
    static std::string value = "Godzilla";
    return b ? std::optional<std::reference_wrapper<std::string>>{value}
             : std::nullopt;
}
 
int main()
{
    std::cout << "create(false) returned "
              << create(false).value_or("empty") << '\n';
 
    // optional-returning factory functions are usable as conditions of while and if
    if (auto str = create2(true)) {
        std::cout << "create2(true) returned " << *str << '\n';
    }
 
    if (auto str = create_ref(true)) {
        // using get() to access the reference_wrapper's value
        std::cout << "create_ref(true) returned " << str->get() << '\n';
        str->get() = "Mothra";
        std::cout << "modifying it changed it to " << str->get() << '\n';
    }
}

Output:

create(false) returned empty
create2(true) returned Godzilla
create_ref(true) returned Godzilla
modifying it changed it to Mothra

See also

variant (C++17)	a type-safe discriminated union (class template)
any (C++17)	Objects that hold instances of any CopyConstructible type. (class)