home | help 
std::experi...al::optional(3)  C++ Standard Libary std::experi...al::optional(3)

NAME
     std::experimental::optional::optional   -	std::experimental::optional::op-
     tional

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(
	std::experimental::in_place_t,				   (7)	(library
     fundamentals
				     std::initializer_list<U>	       TS)
	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 con-
     tained 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  con-
     tained 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  con-
     structor 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 par-
     ticipate in
	the   overload	 resolution  if  std::is_constructible<T,  std::initial-
     izer_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 over-
     loads (2,4).
	-
	T must meet the requirements of MoveConstructible in order to use  over-
     loads (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 follow-
     ing 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::experimen-
     tal::in_place,
						      {'a', 'b', 'c'});

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

Output:
      1 1 abc

See also
	make_optional creates an optional object
		      (function template)

Categories:
	  * Noindexed pages
	  * conditionally noexcept

http://cppreference.com 	   2024.06.10	   std::experi...al::optional(3)
home | help