NAME

std::experimental::optional::optional - std::experimental::optional::optional

Synopsis

constexpr optional() noexcept; (library fundamentals
constexpr optional( std::experimental::nullopt_t ) (1) TS)
noexcept;
optional( const optional& other ); (2) (library fundamentals
TS)
optional( optional&& other ) noexcept(/* see below */); (3) (library fundamentals
TS)
constexpr optional( const T& value ); (4) (library fundamentals
TS)
constexpr optional( T&& value ); (5) (library fundamentals
TS)
template< class... Args > (library fundamentals
constexpr explicit optional( (6) TS)
std::experimental::in_place_t, Args&&... args );
template< class U, class... Args >

constexpr explicit optional( (library fundamentals
std::experimental::in_place_t, (7) TS)
std::initializer_list<U> ilist,

Args&&... args );

Constructs a new optional object.

1) Constructs the object that does not contain a value.
2) Copy constructor: If other contains a value, initializes the contained value as
if direct-initializing (but not direct-list-initializing) an object of type T with
the expression *other. If other does not contain a value, constructs an object that
does not contain a value.
3) Move constructor: If other contains a value, initializes the contained value as
if direct-initializing (but not direct-list-initializing) an object of type T with
the expression std::move(*other) and does not make other empty: a moved-from
optional still contains a value, but the value itself is moved from. If other does
not contain a value, constructs an object that does not contain a value.
4) Constructs an optional object that contains a value, initialized as if
direct-initializing (but not direct-list-initializing) an object of type T with the
expression value. This constructor is constexpr if the constructor of T selected by
direct-initialization is constexpr.
5) Constructs an optional object that contains a value, initialized as if
direct-initializing (but not direct-list-initializing) an object of type T with the
expression std::move(value). This constructor is constexpr if the constructor of T
selected by direct-initialization is constexpr.
6) Constructs an optional object that contains a value, initialized as if
direct-initializing (but not direct-list-initializing) an object of type T from the
arguments std::forward<Args>(args)...
7) Constructs an optional object that contains a value, initialized as if
direct-initializing (but not direct-list-initializing) an object of type T from the
arguments ilist, std::forward<Args>(args).... The function does not participate in
the overload resolution if std::is_constructible<T, std::initializer_list<U>&,
Args&&...>::value != true

Parameters

other - another optional object whose contained value to copy
value - value to initialize the contained value with
args... - arguments to initialize the contained value with
ilist - initializer list to initialize the contained value with

Type requirements

-
T must meet the requirements of CopyConstructible in order to use overloads (2,4).
-
T must meet the requirements of MoveConstructible in order to use overloads (3,5).

Exceptions

2) Throws any exception thrown by the constructor of T.
3) Throws any exception thrown by the constructor of T. Has the following noexcept
declaration:
noexcept specification:
noexcept(std::is_nothrow_move_constructible<T>::value)
.
4-7) Throws any exception thrown by the constructor of T.

Example

// Run this code

#include <experimental/optional>
#include <iostream>
#include <string>
int main()
{
std::experimental::optional<int> o1, // empty
o2 = 1, // init from rvalue
o3 = o2; // copy-constructor

std::experimental::optional<std::string> o4(std::experimental::in_place,
{'a', 'b', 'c'});

std::cout << *o2 << ' ' << *o3 << ' ' << *o4 << '\n';
}

Output:

1 1 abc